# DBE_LOB
#### 接口介绍
高级功能包DBE_LOB支持的接口参见[表1]。
![](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- ORA数据库中空格的实际字节内容为00，GaussDB中空格对应字节内容为ASCII码值（32）。
- 分布式环境中，CLOB类型对象（下文简称CLOB）、BLOB类型对象（下文简称BLOB）以及BFILE文件（下文简称BFILE）最大支持1GB。
- LOBMAXSIZE最大支持1073741771字节。
- DBE_LOB包中的LOB修改接口（如LOB_WRITE、LOB_COPY、CONVERTTOBLOB、LOB_CONVERTTOBLOB、LOADBLOBFROMBFILE等）仅更新内存中的LOB变量，不会自动更新其关联的物理表数据。即使目标行已通过SELECT ... FOR UPDATE锁定，LOB数据变更也不会自动持久化到数据库表中。如需保存修改结果，必须显式执行UPDATE语句。
 
 表1DBE_LOB 
| 接口名称                                                                         | 描述                                                   |
|:---|:---|
| [DBE_LOB.GET_LENGTH]         | 获取并返回指定的LOB的长度（不支持大于2GB）。                           |
| [DBE_LOB.LOB_GET_LENGTH]    | 获取并返回指定的LOB/BFILE的长度。                               |
| [DBE_LOB.OPEN]              | 打开一个LOB，并返回一个LOB的描述符。                                |
| [DBE_LOB.READ]               | 根据指定的长度及起始位置偏移读取LOB内容的一部分到BUFFER缓冲区。                |
| [DBE_LOB.LOB_READ]             | 根据指定的长度及起始位置偏移读取LOB内容的一部分到BUFFER缓冲区（支持BFILE读取）。     |
| [DBE_LOB.WRITE]              | 根据指定长度及起始位置偏移将BUFFER中内容写入到LOB中。                     |
| [DBE_LOB.WRITE_APPEND]        | 根据指定长度将BUFFER中内容写入到LOB的尾部。                           |
| [DBE_LOB.LOB_WRITE_APPEND]    | 根据指定长度将BUFFER中内容写入到LOB的尾部。                           |
| [DBE_LOB.COPY]             | 根据指定长度及起始位置偏移将LOB内容写入到另一个LOB中。                         |
| [DBE_LOB.LOB_COPY]         | 根据指定长度及起始位置偏移将LOB内容写入到另一个LOB中。                        |
| [DBE_LOB.ERASE]               | 根据指定长度及起始位置偏移删除LOB中的内容（不支持大于1GB）。                    |
| [DBE_LOB.LOB_ERASE]         | 根据指定长度及起始位置偏移删除LOB中的内容。                             |
| [DBE_LOB.CLOSE]              | 关闭已经打开的LOB描述符。                                     |
| [DBE_LOB.MATCH]              | 返回一个字符串在LOB中第N次出现的位置。                                |
| [DBE_LOB.COMPARE]           | 比较两个LOB或者两个LOB的某一部分（支持BFILE比较）。                     |
| [DBE_LOB.SUBSTR]              | 用于读取一个LOB的子串，返回读取到的子串。                                |
| [DBE_LOB.LOB_SUBSTR]           | 用于读取一个LOB或者BFILE的子串，返回读取到的子串。                      |
| [DBE_LOB.STRIP]             | 用于截断指定长度的LOB，执行完会将LOB的长度设置为参数指定的长度。                  |
| [DBE_LOB.LOB_STRIP]          | 用于截断指定长度的LOB，执行完会将LOB的长度设置为参数指定的长度。                   |
| [DBE_LOB.CREATE_TEMPORARY]   | 创建一个临时的BLOB或者CLOB。                                  |
| [DBE_LOB.APPEND]            | 将源LOB的内容拼接到目的LOB中。                                  |
| [DBE_LOB.LOB_APPEND]         | 将源LOB的内容拼接到目的LOB中。                                   |
| [DBE_LOB.FREETEMPORARY]     | 删除一个临时的BLOB或者CLOB。                                  |
| [DBE_LOB.FILEOPEN]            | 打开一个数据库BFILE，并返回文件描述符。                               |
| [DBE_LOB.FILECLOSE]         | 关闭由FILEOPEN打开的BFILE。                                 |
| [DBE_LOB.BFILEOPEN]          | 打开一个数据库BFILE。                                        |
| [DBE_LOB.BFILECLOSE]        | 关闭一个由BFILEOPEN打开的BFILE。                            |
| [DBE_LOB.LOADFROMFILE]       | 读取指定位置和长度的数据库BFILE到指定位置的BLOB中。                        |
| [DBE_LOB.LOADFROMBFILE]       | 读取指定位置和长度的数据库BFILE到指定位置的LOB中。                      |
| [DBE_LOB.LOADBLOBFROMFILE]  | 读取指定位置和长度的数据库外部文件到指定位置的BLOB中（不支持大于1GB）。              |
| [DBE_LOB.LOADBLOBFROMBFILE]  | 读取指定位置和长度的数据库BFILE到指定位置的BLOB中。                      |
| [DBE_LOB.LOADCLOBFROMFILE]    | 读取指定位置和长度的数据库外部文件到指定位置的CLOB中（不支持大于1GB）。             |
| [DBE_LOB.LOADCLOBFROMBFILE]  | 读取指定位置和长度的数据库BFILE到指定位置的CLOB中。                       |
| [DBE_LOB.CONVERTTOBLOB]       | 将CLOB转换为BLOB（不支持大于1GB）。                              |
| [DBE_LOB.CONVERTTOCLOB]      | 将BLOB转换为CLOB（不支持大于1GB）。                             |
| [DBE_LOB.LOB_CONVERTTOBLOB]   | 将CLOB转换为BLOB。                                        |
| [DBE_LOB.LOB_CONVERTTOCLOB] | 将BLOB转换为CLOB。                                      |
| [DBE_LOB.GETCHUNKSIZE]    | 获取数据库中CHUNK结构中用于存储LOB数据的最大SIZE。                    |
| [DBE_LOB.LOB_WRITE]         | 将源对象从起始位置读取指定长度内容，写入目标LOB的指定偏移位置，覆盖该位置原内容, 并返回目标LOB。 |
| [DBE_LOB.BFILENAME]          | 根据目录和文件名构造返回DBE_LOB.BFILE。                          |
   
- DBE_LOB.GET_LENGTH
  函数GET_LENGTH获取并返回指定的LOB类型对象的长度，最大支持2GB。
  DBE_LOB.GET_LENGTH原型为：
  ```
  DBE_LOB.GET_LENGTH (
      blob_obj IN BLOB)
  RETURN INTEGER;
  DBE_LOB.GET_LENGTH (
      clob_obj IN CLOB)
  RETURN INTEGER;
  ```
  表2DBE_LOB.GET_LENGTH接口参数说明 
  | 参数                  | 描述                       |
  |:---|:---|
  | blob_obj/clob_obj | 待获取长度的BLOB类型对象/CLOB类型对象。 |
     
  
- DBE_LOB.LOB_GET_LENGTH
  函数LOB_GET_LENGTH获取并返回指定的LOB类型对象/BFILE文件的长度，最大支持32TB。
  DBE_LOB.LOB_GET_LENGTH原型为：
  ```
  DBE_LOB.LOB_GET_LENGTH (
      blob_obj IN BLOB)
  RETURN BIGINT;
  DBE_LOB.LOB_GET_LENGTH (
      clob_obj IN CLOB)
  RETURN BIGINT;
  DBE_LOB.LOB_GET_LENGTH (
      bfile IN DBE_LOB.BFILE)
  RETURN BIGINT;
  ```
  表3DBE_LOB.LOB_GET_LENGTH接口参数说明 
  | 参数                       | 描述                               |
  |:---|:---|
  | blob_obj/clob_obj/bfile | 待获取长度的BLOB类型对象/CLOB类型对象/BFILE文件。 |
     
  
- DBE_LOB.OPEN
  存储过程打开一个LOB类型对象，并返回一个LOB描述符，该过程无实际意义，仅用于兼容。
  DBE_LOB.OPEN原型为：
  ```
  DBE_LOB.OPEN (
      lob INOUT BLOB);
  DBE_LOB.OPEN (
      lob INOUT CLOB);
  DBE_LOB.OPEN (
      bfile     INOUT DBE_LOB.BFILE,
      open_mode IN    TEXT DEFAULT 'null');
  ```
  表4DBE_LOB.OPEN接口参数说明 
  | 参数       | 描述                            |
  |:---|:---|
  | lob/bfile | 被打开的BLOB类型对象/CLOB类型对象/BFILE文件。 |
  | open_mode | 操作模式，现支持\[R,W,A,RB,WB,AB\]。     |
     
  
- DBE_LOB.READ
  存储过程READ根据指定长度及起始位置偏移读取LOB类型对象的一部分到out_put缓冲区。
  DBE_LOB.READ原型为：
  ```
  DBE_LOB.READ (
      blob_obj IN  BLOB,
      amount   IN  INTEGER,
      off_set  IN  INTEGER,
      out_put  OUT RAW);
  DBE_LOB.READ (
      clob_obj IN  CLOB,
      amount   IN  INTEGER,
      off_set  IN  INTEGER,
      out_put  OUT VARCHAR2);
  ```
  表5DBE_LOB.READ接口参数说明 
  | 参数                 | 说明                                                                                |
  |:---|:---|
  | blob_obj/clob_obj | 待读入的BLOB/CLOB类型对象。                                                               |
  | amount             | 读入长度。 说明： 如果读入长度小于1，或大于32767，则报错。 |
  | off_set            | 指定从参数LOB类型对象开始读取偏移（即相对LOB类型对象起始位置的字节数）的位置。如果偏移量小于1或者大于LOB类型对象长度，则报错。初始位置为1。        |
  | out_put           | 读取参数LOB类型对象后存放的目标缓冲区。                                                             |
     
  
- DBE_LOB.LOB_READ
  存储过程LOB_READ根据指定长度及起始位置偏移读取LOB类型对象/BFILE文件的一部分到out_put缓冲区。
  DBE_LOB.LOB_READ原型为：
  ```
  DBE_LOB.LOB_READ(
      blob_obj IN    BLOB,
      amount   INOUT BIGINT,
      off_set  IN    BIGINT,
      out_put  OUT   RAW);
  DBE_LOB.LOB_READ(
      clob_obj IN    CLOB,
      amount   INOUT BIGINT,
      off_set  IN    BIGINT,
      out_put  OUT   VARCHAR2);
  DBE_LOB.LOB_READ(
      bfile   IN    DBE_LOB.BFILE,
      amount  INOUT BIGINT,
      off_set IN    BIGINT,
      out_put OUT   RAW);
  ```
  表6DBE_LOB.LOB_READ接口参数说明 
  | 参数                     | 说明                                                                                                    |
  |:---|:---|
  | blob_obj/clob_obj/bfile | 待读入的BLOB类型对象/CLOB类型对象/BFILE文件（支持大于1GB）。                                                             |
  | amount                | IN参数为读入长度，OUT参数为实际读取的长度。 说明： 如果读入长度小于1，或大于32767，则报错。 |
  | off_set                | 指定从参数LOB类型对象/BFILE文件开始读取偏移（即相对LOB内容起始位置的字节数）的位置。如果偏移量小于1或者大于LOB类型对象/BFILE文件长度，则报错。初始位置为1。            |
  | out_put                 | 读取参数LOB类型对象/BFILE文件后存放的目标缓冲区。                                                                       |
     
  
- DBE_LOB.WRITE
  存储过程WRITE根据指定长度及起始位置将source中内容写入到LOB类型对象中。
  DBE_LOB.WRITE原型为：
  ```
  DBE_LOB.WRITE (
      blob_obj INOUT BLOB,
      amount   IN    INTEGER,
      off_set  IN    INTEGER,
      source   IN    RAW);
  DBE_LOB.WRITE (
      clob_obj INOUT CLOB,
      amount   IN    INTEGER,
      off_set  IN    INTEGER,
      source   IN    VARCHAR2);
  ```
  表7DBE_LOB.WRITE接口参数说明 
  | 参数                 | 说明                                                                                                                                                           |
  |:---|:---|
  | blob_obj/clob_obj | 待写入的BLOB类型对象/CLOB类型对象。                                                                                                                                     |
  | amount         | 写入长度，最大支持32767字节。 说明： 如果写入长度小于1或写入长度大于待写入的内容长度，则报错。                                                          |
  | off_set          | 指定从BLOB类型对象/CLOB类型对象开始写入偏移（即相对LOB内容起始位置的字节数）的位置。 说明： 如果偏移量小于1或者大于LOBMAXSIZE时，则报错。初始位置是1，最大值为LOB类型对象最大长度。 |
  | source          | 待写入的内容。                                                                                                                                                      |
     
  
- DBE_LOB.WRITE_APPEND
  存储过程WRITE_APPEND根据指定长度将source_obj中内容写入到LOB类型对象的尾部。
  DBE_LOB.WRITE_APPEND原型为：
  ```
  DBE_LOB.WRITE_APPEND (
      blob_obj   INOUT BLOB,
      amount     IN    INTEGER,
      source_obj IN    RAW);
  DBE_LOB.WRITE_APPEND (
      clob_obj   INOUT CLOB,
      amount     IN    INTEGER,
      source_obj IN    VARCHAR2);
  ```
  表8DBE_LOB.WRITE_APPEND接口参数说明 
  | 参数                 | 说明                                                                                                  |
  |:---|:---|
  | blob_obj/clob_obj | 待写入的指定BLOB类型对象/CLOB类型对象。                                                                          |
  | amount             | 写入长度，最大支持32767字节。 说明： 如果写入长度小于1或写入长度大于待写入的内容长度，则报错。 |
  | source_obj         | 待写入的内容。                                                                                            |
     
  
- DBE_LOB.LOB_WRITE_APPEND
  存储过程LOB_WRITE_APPEND根据指定长度将source_obj中内容写入到LOB类型对象的尾部。
  DBE_LOB.LOB_WRITE_APPEND原型为：
  ```
  DBE_LOB.LOB_WRITE_APPEND(
      blob_obj    INOUT BLOB,
      amount      IN    INTEGER,
      source_obj  IN    RAW);
  DBE_LOB.LOB_WRITE_APPEND (
      clob_obj    INOUT CLOB,
      amount      IN    INTEGER,
      source_obj  IN    VARCHAR2);
  ```
  表9DBE_LOB.LOB_WRITE_APPEND接口参数说明 
  | 参数              | 说明                                                                                               |
  |:---|:---|
  | blob_obj/clob_obj | 待写入的指定BLOB类型对象/CLOB类型对象。                                                                            |
  | amount          | 写入长度，最大支持32767字节。 说明： 如果写入长度小于1或写入长度大于待写入的内容长度，则报错。 |
  | source_obj      | 待写入的内容。                                                                                           |
     
  
- DBE_LOB.COPY
  存储过程COPY根据指定长度及起始位置偏移将LOB类型对象内容复制到另一个LOB类型对象中。
  DBE_LOB.COPY原型为：
  ```
  DBE_LOB.COPY (
      dest_lob   INOUT BLOB,
      src_lob    IN    BLOB,
      len        IN    INTEGER,
      dest_start IN    INTEGER DEFAULT 1,
      src_start  IN    INTEGER DEFAULT 1);
  ```
  表10DBE_LOB.COPY接口参数说明 
  | 参数         | 说明                                          |
  |:---|:---|
  | dest_lob  | 待拷入的LOB类型对象。                               |
  | src_lob | 待拷出的LOB类型对象。                                |
  | len     | 复制长度。                                       |
  | dest_start | 指定从dest_lob内容开始拷入偏移（即相对LOB内容起始位置的字节数）的位置。 |
  | src_start  | 指定从src_lob内容开始拷出偏移（即相对LOB内容起始位置的字节数）的位置。    |
     
  
- DBE_LOB.LOB_COPY
  存储过程COPY根据指定长度及起始位置偏移将LOB类型对象内容复制到另一个LOB类型对象中。
  DBE_LOB.LOB_COPY原型为：
  ```
  DBE_LOB.LOB_COPY(
      blob_obj    INOUT BLOB,
      source_obj  IN    BLOB,
      amount      IN    BIGINT,
      dest_offset IN    BIGINT DEFAULT 1,
      src_offset  IN    BIGINT DEFAULT 1);
  DBE_LOB.LOB_COPY(
      clob_obj    INOUT CLOB,
      source_obj  IN    CLOB,
      amount      IN    BIGINT,
      dest_offset IN    BIGINT DEFAULT 1,
      src_offset  IN    BIGINT DEFAULT 1);
  ```
  表11DBE_LOB.LOB_COPY接口参数说明 
  | 参数                 | 说明                                                                                                                                                              |
  |:---|:---|
  | blob_obj/clob_obj | 待拷入的LOB类型对象。                                                                                                                                                      |
  | source_obj            | 待拷出的LOB类型对象。                                                                                                                                                       |
  | amount            | 复制长度。 说明： 如果拷入长度小于1或拷入长度大于LOBMAXSIZE，则报错。                                                                          |
  | dest_offset        | 指定从blob_obj/clob_obj内容开始拷入偏移（即相对LOB类型对象起始位置的字节数/字符数，BLOB对象以字节为单位，CLOB对象以字符为单位）的位置。 说明： 如果偏移量小于1或者大于LOBMAXSIZE，则报错。 |
  | src_offset        | 指定从source_obj内容开始拷出偏移（即相对LOB类型对象起始位置的字节数/字符数，BLOB对象以字节为单位，CLOB对象以字符为单位）的位置。 说明： 如果偏移量小于1则报错。                    |
     
  
- DBE_LOB.ERASE
  存储过程ERASE根据指定长度及起始位置偏移删除blob_obj中的内容（不支持大于1GB），blob_obj中删除部分的字节填充为0。
  DBE_LOB.ERASE原型为：
  ```
  DBE_LOB.ERASE (
      blob_obj INOUT BLOB,
      amount   INOUT INTEGER,
      off_set  IN    INTEGER DEFAULT 1);
  ```
  表12DBE_LOB.ERASE接口参数说明 
  | 参数       | 说明                                                                                                                         |
  |:---|:---|
  | blob_obj | IN参数为待删除内容的LOB类型对象，OUT参数为删除指定部分后的LOB类型对象，传空报错。                                                                          |
  | amount   | IN参数为待删除的长度（BLOB类型对象以字节为单位），OUT参数为实际删除的长度。 说明： 如果删除长度小于1或传空，则报错。           |
  | off_set   | 指定从LOB类型对象开始删除偏移（即相对BLOB内容起始位置的字节数，不支持大于1GB）的位置。 说明： 如果偏移量小于1或偏移量传空，则报错。 |
     
  
- DBE_LOB.LOB_ERASE
  存储过程LOB_ERASE根据指定长度及起始位置偏移删除LOB类型对象中的内容，BLOB类型对象中删除部分的字节填充为0，CLOB类型对象中删除部分的字符填充为空格，支持LOB类型对象大于1GB，最大支持32TB。
  DBE_LOB.LOB_ERASE原型为：
  ```
  DBE_LOB.LOB_ERASE (
      blob_obj INOUT BLOB,
      amount   INOUT BIGINT,
      off_set  IN    BIGINT DEFAULT 1);
  DBE_LOB.LOB_ERASE (
      clob_obj INOUT CLOB,
      amount   INOUT BIGINT,
      off_set  IN    BIGINT DEFAULT 1);
  ```
  表13DBE_LOB.LOB_ERASE接口参数说明 
  | 参数                  | 说明                                                                                                                           |
  |:---|:---|
  | blob_obj/clob_obj | IN参数为待删除内容的LOB类型对象，OUT参数为删除指定部分后的LOB类型对象，传空报错。                                                                                 |
  | amount              | IN参数为待删除的长度（BLOB类型对象以字节为单位，CLOB类型对象以字符为单位），OUT参数为实际删除的长度。 说明： 如果删除长度小于1或传空，则报错。 |
  | off_set             | 指定从LOB类型对象开始删除偏移（即相对BLOB内容起始位置的字节数/相对CLOB内容起始位置的字符数）的位置。 说明： 如果偏移量小于1或偏移量传空，则报错。 |
     
  
- DBE_LOB.CLOSE
  存储过程CLOSE关闭已经打开的LOB类型对象描述符。
  DBE_LOB.CLOSE原型为：
  ```
  DBE_LOB.CLOSE(
      lob IN BLOB);
  DBE_LOB.CLOSE (
      lob IN CLOB);
  DBE_LOB.CLOSE (
      file IN INTEGER);
  ```
  表14DBE_LOB.CLOSE接口参数说明 
  | 参数    | 说明                                  |
  |:---|:---|
  | lob/file | 待关闭的BLOB类型对象/CLOB类型对象/BFILE文件类型对象。 |
     
  
- DBE_LOB.MATCH
  该函数返回字符串在LOB类型对象或者BFILE文件中第N次出现的位置，如果输入的是一些无效值会返回NULL值。支持LOB类型对象或者BFILE文件大于1GB，最大支持32TB。
  DBE_LOB.MATCH原型为：
  ```
  DBE_LOB.MATCH(
      blob_obj    IN BLOB,
      blob_obj2   IN RAW,
      beg_index   IN BIGINT DEFAULT 1,
      occur_index IN BIGINT DEFAULT 1)
  RETURN BIGINT;
  DBE_LOB.MATCH(
      clob_obj    IN CLOB,
      clob_obj2   IN VARCHAR2,
      beg_index   IN BIGINT DEFAULT 1,
      occur_index IN BIGINT DEFAULT 1)
  RETURN BIGINT;
  DBE_LOB.MATCH(
      bfile       IN DBE_LOB.BFILE,
      blob_obj2     IN RAW,
      beg_index   IN BIGINT DEFAULT 1,
      occur_index IN BIGINT DEFAULT 1)
  RETURN BIGINT;
  ```
  表15DBE_LOB.MATCH接口参数说明 
  | 参数                       | 说明                                                                                                                                                  |
  |:---|:---|
  | blob_obj/clob_obj/bfile | 要查找的BLOB类型对象/CLOB类型对象描述符，或者BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开），传空返回NULL。                                                                              |
  | blob_obj2/clob_obj2        | 要匹配的模式，对于BLOB类型对象/BFILE文件是由一组RAW类型的数据组成，对于CLOB类型对象是由一组VARCHAR2类型的数据组成，传空返回NULL。                                                                     |
  | beg_index                | 对于BLOB类型对象/BFILE文件是以字节为单位的绝对偏移量，对于CLOB类型对象是以字符为单位的偏移量，模式匹配的起始位置是1。 说明： 有效范围为1\~LOBMAXSIZE，超过返回NULL。 |
  | occur_index               | 模式匹配的次数，最小值为1。 说明： 若大于模式串在LOB类型对象中最大能匹配上的次数，则返回0，若不在范围1\~LOBMAXSIZE，则返回NULL。                           |
     
  
- DBE_LOB.COMPARE
  该函数比较部分或者全部LOB类型对象或BFILE文件。
  - 如果比较的结果相等返回0，否则返回非零的值。
  
  - 如果第一个LOB类型对象比第二个小，返回-1；如果第一个LOB类型对象比第二个大，返回1。
  
  - 如果len、start1、start2这几个参数有无效参数返回NULL，有效偏移量范围是1\~LOBMAXSIZE。
  
  - 如果start_pos1、start_pos2同时超过LOB类型对象/BFILE文件长度，则返回0。
  
  
  DBE_LOB.COMPARE原型为：
  ```
  DBE_LOB.COMPARE (
      lob1       IN BLOB,
      lob2       IN BLOB,
      len        IN BIGINT DEFAULT 1073741312,
      start_pos1 IN BIGINT DEFAULT 1,
      start_pos2 IN BIGINT DEFAULT 1)
  RETURN INTEGER;
  DBE_LOB.COMPARE (
      lob1       IN CLOB,
      lob2       IN CLOB,
      len        IN BIGINT DEFAULT 1073741312,
      start_pos1 IN BIGINT DEFAULT 1,
      start_pos2 IN BIGINT DEFAULT 1)
  RETURN INTEGER;
  DBE_LOB.COMPARE (
      file1       IN DBE_LOB.BFILE,
      file2       IN DBE_LOB.BFILE,
      len        IN BIGINT DEFAULT 1073741312,
      start_pos1 IN BIGINT DEFAULT 1,
      start_pos2 IN BIGINT DEFAULT 1)
  RETURN INTEGER;
  ```
  表16DBE_LOB.COMPARE接口参数说明 
  | 参数          | 说明                                                          |
  |:---|:---|
  | lob1/file1 | 第一个要比较的BLOB类型对象/CLOB类型对象/BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开）。 |
  | lob2/file2 | 第二个要比较的BLOB类型对象/CLOB类型对象/BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开）。   |
  | len        | 要比较的字符数或者字节数，默认值为1073741312。                                 |
  | start_pos1   | 第一个LOB类型对象描述符偏移量，初始位置是1，最大值为LOB类型对象最大长度。                      |
  | start_pos2    | 第二个LOB类型对象描述符的偏移量，初始位置是1，最大值为LOB类型对象最大长度。                    |
     
  
- DBE_LOB.SUBSTR
  该函数用于读取一个LOB类型对象的子串，返回读取的子串。
  DBE_LOB.SUBSTR原型为：
  ```
  DBE_LOB.SUBSTR(
      lob_loc IN BLOB,
      amount  IN INTEGER DEFAULT 32767,
      off_set IN INTEGER  DEFAULT 1)
  RETURN RAW;
  DBE_LOB.SUBSTR(
      lob_loc IN CLOB,
      amount  IN INTEGER DEFAULT 32767,
      off_set IN INTEGER  DEFAULT 1)
  RETURN VARCHAR2;
  ```
  表17DBE_LOB.SUBSTR接口参数说明 
  | 参数        | 说明                                                                                                 |
  |:---|:---|
  | lob_loc | 将要读取子串的LOB类型对象描述符，对于BLOB类型对象的返回值是读取的RAW类型，对于CLOB类型对象的返回值是VARCHAR2类型。                              |
  | amount   | 要读取的字节数或者字符数量。 说明： 范围为1\~32767，超出返回NULL。            |
  | off_set | 从开始位置偏移的字符数或者字节数量。 说明： 范围为1\~LOBMAXSIZE，超出返回NULL。 |
     
  
- DBE_LOB.LOB_SUBSTR
  该函数用于读取一个LOB类型对象或者BFILE文件的子串，返回读取的子串，LOB类型对象或BFILE文件最大支持32TB。
  DBE_LOB.LOB_SUBSTR原型为：
  ```
  DBE_LOB.LOB_SUBSTR(
      lob_loc IN BLOB,
      amount  IN INTEGER DEFAULT 32767,
      off_set IN BIGINT  DEFAULT 1)
  RETURN RAW;
  DBE_LOB.LOB_SUBSTR(
      lob_loc IN CLOB,
      amount  IN INTEGER DEFAULT 32767,
      off_set IN BIGINT  DEFAULT 1)
  RETURN VARCHAR2;
  DBE_LOB.LOB_SUBSTR(
      bfile   IN DBE_LOB.BFILE,
      amount  IN INTEGER DEFAULT 32767,
      off_set IN BIGINT  DEFAULT 1)
  RETURN RAW;
  ```
  表18DBE_LOB.LOB_SUBSTR接口参数说明 
  | 参数              | 说明                                                                                                            |
  |:---|:---|
  | lob_loc/bfile | 将要读取子串的LOB类型对象描述符或BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开），对于BLOB类型对象/BFILE文件的返回值是读取的RAW类型，对于CLOB类型对象的返回值是VARCHAR2类型。 |
  | amount      | 要读取的字节数或者字符数量。 说明： 范围为1\~32767，超出返回NULL。                       |
  | off_set       | 从开始位置偏移的字符数或者字节数量。 说明： 范围为1\~LOBMAXSIZE，超出返回NULL。               |
     
  
- DBE_LOB.STRIP
  STRIP用于截断指定长度的LOB类型对象，执行完STRIP会将LOB类型对象的长度设置为newlen参数指定的长度。
  DBE_LOB.STRIP原型为：
  ```
  DBE_LOB.STRIP(
      lob_loc INOUT BLOB,
      newlen  IN INTEGER);
  DBE_LOB.STRIP(
      lob_loc INOUT CLOB,
      newlen  IN INTEGER);
  ```
  表19DBE_LOB.STRIP接口参数说明 
  | 参数        | 说明                                              |
  |:---|:---|
  | lob_loc | IN参数为待读入的指定LOB类型对象，OUT参数为截断后的对象，传空报错。        |
  | newlen  | 截断后LOB类型对象的新长度，对于BLOB类型对象是字节数，对于CLOB类型对象是字符数。 |
     
  
- DBE_LOB.LOB_STRIP
  LOB_STRIP用于截断指定长度的LOB类型对象，执行完LOB_STRIP会将LOB类型对象的长度设置为newlen参数指定的长度。支持LOB类型对象大于1GB，最大支持32TB。
  DBE_LOB.LOB_STRIP原型为：
  ```
  DBE_LOB.LOB_STRIP(
      lob_loc INOUT BLOB,
      newlen  IN    BIGINT);
  DBE_LOB.LOB_STRIP(
      lob_loc INOUT CLOB,
      newlen  IN    BIGINT);
  ```
  表20DBE_LOB.LOB_STRIP接口参数说明 
  | 参数        | 说明                                                                                                                       |
  |:---|:---|
  | lob_loc | IN参数为待读入的指定LOB类型对象，OUT参数为截断后的对象，传空报错。                                                                                      |
  | newlen    | 截断后LOB类型对象的新长度，对于BLOB类型对象是字节数，对于CLOB类型对象是字符数。 说明： 小于1返回NULL，大于LOB类型对象的长度，报错。 |
     
  
- DBE_LOB.CREATE_TEMPORARY
  CREATE_TEMPORARY创建一个临时的BLOB类型对象或者CLOB类型对象，CREATE_TEMPORARY仅用于语法上的兼容，并无实际意义。
  DBE_LOB.CREATE_TEMPORARY原型为：
  ```
  DBE_LOB.CREATE_TEMPORARY (
      lob_loc INOUT BLOB,
      cache   IN    BOOLEAN,
      dur     IN    INTEGER DEFAULT 10);
  DBE_LOB.CREATE_TEMPORARY (
      lob_loc INOUT CLOB,
      cache   IN    BOOLEAN,
      dur     IN    INTEGER DEFAULT 10);
  ```
  表21DBE_LOB.CREATE_TEMPORARY接口参数说明 
  | 参数      | 说明          |
  |:---|:---|
  | lob_loc | LOB类型对象描述符。 |
  | cache    | 仅用于语法上的兼容。 |
  | dur    | 仅用于语法上的兼容。 |
     
  
- DBE_LOB.APPEND
  存储过程APPEND将source_obj拼接在目标LOB类型对象之后。
  DBE_LOB.APPEND原型为：
  ```
  DBE_LOB.APPEND (
      blob_obj INOUT BLOB,
      source_obj  IN    BLOB);
  DBE_LOB.APPEND (
      clob_obj INOUT CLOB,
      source_obj  IN    CLOB);
  ```
  表22DBE_LOB.APPEND接口参数说明 
  | 参数               | 说明                      |
  |:---|:---|
  | blob_obj/clob_obj | 要写入的BLOB类型对象/CLOB类型对象。 |
  | source_obj         | 读取的BLOB类型对象/CLOB类型对象。  |
     
  
- DBE_LOB.LOB_APPEND
  存储过程LOB_APPEND将source_obj拼接在目标LOB类型对象之后。
  DBE_LOB.LOB_APPEND原型为：
  ```
  DBE_LOB.LOB_APPEND(
      blob_obj   INOUT BLOB,
      source_obj IN    BLOB);
  DBE_LOB.LOB_APPEND(
      clob_obj   INOUT CLOB,
      source_obj IN    CLOB);
  ```
  表23DBE_LOB.LOB_APPEND接口参数说明 
  | 参数               | 说明                    |
  |:---|:---|
  | blob_obj/clob_obj | 要写入的BLOB类型对象/CLOB类型对象。 |
  | source_obj        | 读取的BLOB类型对象/CLOB类型对象。   |
     
  
- DBE_LOB.FREETEMPORARY
  存储过程FREETEMPORARY用于释放由CREATE_TEMPORARY创建的LOB类型对象。
  DBE_LOB.FREETEMPORARY原型为：
  ```
  DBE_LOB.FREETEMPORARY (
      blob INOUT BLOB);
  DBE_LOB.FREETEMPORARY (
      clob INOUT CLOB);
  ```
  表24DBE_LOB.FREETEMPORARY接口参数说明 
  | 参数      | 说明                     |
  |:---|:---|
  | blob/clob | 要释放的BLOB类型对象/CLOB类型对象。 |
     
  
- DBE_LOB.FILEOPEN
  FILEOPEN用于打开数据库外部BFILE类型，并返回该文件对应的文件描述符（fd），一个会话最多支持打开10个BFILE文件。
  BFILE类型定义为：
  ```
  DBE_LOB.BFILE (
      directory TEXT,
      filename  TEXT,
      fd        INTEGER);
  ```
  DBE_LOB.FILEOPEN原型为：
  ```
  DBE_LOB.FILEOPEN (
      bfile     IN DBE_LOB.BFILE,
      open_mode IN TEXT)
  RETURN INTEGER;
  ```
  表25DBE_LOB.FILEOPEN接口参数说明 
  | 参数         | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
  |:---|:---|
  | bfile      | 要打开的数据库外部文件（BFILE类型包含了文件路径和文件名、文件描述符（fd））。 说明： 该变量中包含文件目录的位置directory，文件名filename。 - 文件目录的位置，需要添加到系统表[PG_DIRECTORY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0983.html)中，如果传入的路径和[PG_DIRECTORY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0983.html)中的路径不匹配，会报路径不存在的错误。  - 在打开GUC参数safe_data_path时，用户只能通过高级包读写safe_data_path指定文件路径下的文件。  - 文件名，包含扩展（文件类型），不包括路径名。如果文件名中包含路径，在OPEN中会被忽略，在Unix系统中，文件名不能以/.结尾。   |
  | open_mode | 文件打开模式，只支持read模式（r），其他模式报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
     
  
- DBE_LOB.FILECLOSE
  该函数用于关闭数据外部BFILE文件。
  DBE_LOB.FILECLOSE原型为：
  ```
  DBE_LOB.FILECLOSE (
      file IN INTEGER);
  ```
  表26DBE_LOB.FILECLOSE接口参数说明 
  | 参数   | 说明                              |
  |:---|:---|
  | file | 要关闭的数据库外部文件（由FILEOPEN返回的文件描述符）。 |
     
  
- DBE_LOB.BFILEOPEN
  BFILEOPEN用于打开数据库外部BFILE文件，一个会话最多支持打开10个BFILE文件。
  DBE_LOB.BFILEOPEN原型为：
  ```
  DBE_LOB.BFILEOPEN (
      bfile     INOUT DBE_LOB.BFILE,
      open_mode IN    TEXT DEFAULT 'R');
  ```
  表27DBE_LOB.BFILEOPEN接口参数说明 
  | 参数        | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  |:---|:---|
  | bfile     | INOUT参数为打开的数据库BFILE文件。 说明： 该变量中包含文件目录的位置directory，文件名filename。 - 文件目录的位置，需要添加到系统表[PG_DIRECTORY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0983.html)中，如果传入的路径和[PG_DIRECTORY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0983.html)中的路径不匹配，会报路径不存在的错误。  - 在打开GUC参数safe_data_path时，用户只能通过高级包读写safe_data_path指定文件路径下的文件。  - 文件名，包含扩展（文件类型），不包括路径名。如果文件名中包含路径，在OPEN中会被忽略，在Unix系统中，文件名不能以/.结尾。   |
  | open_mode | 文件打开模式，只支持read模式（r），其他模式报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
     
  示例：
  ```
  -- 获取bfile文件的子串（文件内容为ABCD）。
  DECLARE
  bfile dbe_lob.bfile;
  BEGIN
  bfile = DBE_LOB.BFILENAME(dir_name, file_name); -- 获取对应bfile文件对象。
  DBE_LOB.bfileopen(bfile, 'r'); -- 打开bfile文件。
  RAISE NOTICE 'res:%', DBE_LOB.lob_substr(bfile, 10, 1); -- 获取子串，并打印。
  DBE_LOB.bfileclose(bfile);-- 关闭bfile文件。
  END;
  /
  NOTICE:  res:41
  ANONYMOUS BLOCK EXECUTE
  ```
  
- DBE_LOB.BFILECLOSE
  这个存储过程用于关闭数据库外部BFILE文件。
  DBE_LOB.BFILECLOSE原型为：
  ```
  DBE_LOB.BFILECLOSE (
      bfile INOUT DBE_LOB.BFILE);
  ```
  表28DBE_LOB.BFILECLOSE接口参数说明 
  | 参数    | 说明                     |
  |:---|:---|
  | bfile | INOUT参数为关闭的数据库BFILE文件。 |
     
  
- DBE_LOB.LOADFROMFILE
  该函数用于将BFILE外部文件读取到BLOB类型对象中，并以RAW类型返回该对象。
  DBE_LOB.LOADFROMFILE原型为：
  ```
  DBE_LOB.LOADFROMFILE (
      dest_lob    IN BLOB,
      src_file    IN INTEGER,
      amount      IN INTEGER,
      dest_offset IN INTEGER,
      src_offset  IN INTEGER)
  RETURN RAW;
  ```
  表29DBE_LOB.LOADFROMFILE接口参数说明 
  | 参数            | 说明                                                                                                                                                                                                                                                                                                                                              |
  |:---|:---|
  | dest_lob      | 目标BLOB类型对象，BFILE文件将读取到这个文件中的指定偏移位置。                                                                                                                                                                                                                                                                                                               |
  | src_bfile      | 需要读取的源BFILE文件。                                                                                                                                                                                                                                                                                                                                   |
  | amount          | 读取BFILE文件内容的长度。 说明： 长度小于1或者大于32767则报错。                                                                                                                                                                                                                                                           |
  | dest_offset | BLOB类型对象的偏移长度。 说明： 偏移量小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                                      |
  | src_offset   | BFILE文件的偏移长度。 说明： - 偏移量小于1或者大于LOBMAXSIZE则报错。  - amount + src_offset 大于 src_bfile的长度 + 1 则报错。   |
     
  
- DBE_LOB.LOADFROMBFILE
  LOADFROMBFILE用于将BFILE外部文件读取到LOB类型对象中。
  DBE_LOB.LOADFROMBFILE原型为：
  ```
  DBE_LOB.LOADFROMBFILE (
      dest_lob    INOUT BLOB,
      src_file    IN    DBE_LOB.BFILE,
      amount      IN    BIGINT,
      dest_offset IN    BIGINT DEFAULT 1,
      src_offset  IN    BIGINT DEFAULT 1)
  RETURN BLOB;
  DBE_LOB.LOADFROMBFILE (
      dest_lob    INOUT CLOB,
      src_file    IN    DBE_LOB.BFILE,
      amount      IN    BIGINT,
      dest_offset IN    BIGINT DEFAULT 1,
      src_offset  IN    BIGINT DEFAULT 1)
  RETURN CLOB;
  ```
  表30DBE_LOB.LOADFROMBFILE接口参数说明 
  | 参数        | 说明                                                                                                                                                                                                                                                                                                                                               |
  |:---|:---|
  | dest_lob   | IN参数为目标LOB类型对象，BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开）将读取到这个对象中，OUT参数为完成读取后返回的LOB类型对象，大小支持超过1GB，最大支持32TB。                                                                                                                                                                                                                                              |
  | src_file    | 需要读取的源BFILE文件，BFILE文件的大小支持超过1GB，最大支持32TB。                                                                                                                                                                                                                                                                                                        |
  | amount     | 读取BFILE文件内容和写入LOB类型对象的长度。 说明： 长度小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                              |
  | dest_offset | LOB类型对象的偏移长度。 说明： 偏移量小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                                         |
  | src_offset  | BFILE文件的偏移长度。 说明： - 偏移量小于1或者大于LOBMAXSIZE则报错。  - amount + src_offset 大于 src_bfile的长度 + 1 则报错。   |
     
  
- DBE_LOB.LOADBLOBFROMFILE
  该函数用于将BFILE外部文件读取到BLOB类型对象中，并以RAW类型返回该对象。
  DBE_LOB.LOADBLOBFROMFILE原型为：
  ```
  DBE_LOB.LOADBLOBFROMFILE (
      dest_lob    IN BLOB,
      src_file    IN INTEGER,
      amount      IN INTEGER,
      dest_offset IN INTEGER,
      src_offset  IN INTEGER)
  RETURN RAW;
  ```
  表31DBE_LOB.LOADBLOBFROMFILE接口参数说明 
  | 参数         | 说明                                                                                                                                                                                                                                                                                                                                         |
  |:---|:---|
  | dest_lob    | 目标BLOB类型对象，BFILE文件将读取到这个对象中。                                                                                                                                                                                                                                                                                                              |
  | src_file   | 需要读取的源BFILE文件。                                                                                                                                                                                                                                                                                                                            |
  | amount      | BLOB类型对象的长度，超过这个阈值的文件将不会保存到BLOB类型对象中。 说明： 长度小于1或者大于32767则报错。                                                                                                                                                                                                                             |
  | dest_offset  | BLOB类型对象的偏移长度。 说明： 偏移量小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                                  |
  | src_offset | BFILE文件的偏移长度。 说明： - 偏移量小于1或者大于LOBMAXSIZE则报错。  - amount + src_offset 大于 src_bfile的长度 + 1 则报错。   |
     
  
- DBE_LOB.LOADBLOBFROMBFILE
  LOADBLOBFROMBFILE用于将BFILE外部文件读取到BLOB类型对象中。
  DBE_LOB.LOADBLOBFROMBFILE原型为：
  ```
  DBE_LOB.LOADBLOBFROMFILE (
      dest_lob    INOUT BLOB,
      src_file    IN    DBE_LOB.BFILE,
      amount      IN    BIGINT,
      dest_offset INOUT BIGINT,
      src_offset  INOUT BIGINT)
  ```
  表32DBE_LOB.LOADBLOBFROMBFILE接口参数说明 
  | 参数           | 说明                                                                                                                                                                                                                                                                                                                                            |
  |:---|:---|
  | dest_lob     | IN参数为目标BLOB类型对象，BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开）将读取到这个对象中，OUT参数为完成读取后返回的BLOB类型对象。大小支持超过1GB，最大支持32TB。                                                                                                                                                                                                                                        |
  | src_file      | 需要读取的源BFILE文件，BFILE文件的大小支持超过1GB，最大支持32TB。                                                                                                                                                                                                                                                                                                     |
  | amount        | BLOB类型对象的长度，超过这个阈值的文件将不会保存到BLOB类型对象中。 说明： 长度小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                               |
  | dest_offset | BLOB类型对象的偏移长度。 说明： 偏移量小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                                   |
  | src_offset    | BFILE文件的偏移长度。 说明： - 偏移量小于1或者大于LOBMAXSIZE则报错。  - amount + src_offset 大于 src_bfile的长度 + 1 则报错。   |
     
  
- DBE_LOB.LOADCLOBFROMFILE
  该函数用于将BFILE外部文件读取到CLOB类型对象中，并以RAW类型返回该对象。
  DBE_LOB.LOADCLOBFROMFILE原型为：
  ```
  DBE_LOB.LOADCLOBFROMFILE (
      dest_lob    IN CLOB,
      src_file    IN INTEGER,
      amount      IN INTEGER,
      dest_offset IN INTEGER,
      src_offset  IN INTEGER)
  RETURN RAW;
  ```
  表33DBE_LOB.LOADCLOBFROMFILE接口参数说明 
  | 参数           | 说明                                                                                                                                                                                                                                                                                                                                        |
  |:---|:---|
  | dest_lob   | 目标CLOB类型对象，BFILE文件将读取到这个文件中。                                                                                                                                                                                                                                                                                                             |
  | src_file   | 需要读取的源BFILE文件。                                                                                                                                                                                                                                                                                                                            |
  | amount       | CLOB类型对象的长度。 说明： 长度小于1或者大于32767则报错。                                                                                                                                                                                                                                                       |
  | dest_offset | CLOB类型对象的偏移长度。 说明： 偏移量小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                                 |
  | src_offset    | BFILE文件的偏移长度。 说明： - 偏移量小于1或者大于LOBMAXSIZE则报错。  - amount + src_offset 大于 src_bfile的长度 + 1 则报错。   |
     
  
- DBE_LOB.LOADCLOBFROMBFILE
  LOADCLOBFROMBFILE用于将BFILE外部文件读取到CLOB类型对象中。
  DBE_LOB.LOADCLOBFROMBFILE原型为：
  ```
  DBE_LOB.LOADCLOBFROMBFILE (
      dest_lob    INOUT CLOB,
      src_file    IN    DBE_LOB.BFILE,
      amount      IN    BIGINT,
      dest_offset INOUT BIGINT,
      src_offset  INOUT BIGINT)
  ```
  表34DBE_LOB.LOADCLOBFROMBFILE接口参数说明 
  | 参数            | 说明                                                                                                                                                                                                                                                                                                                                         |
  |:---|:---|
  | dest_lob    | IN参数为目标CLOB类型对象，BFILE文件（必须先通过DBE_LOB.BFILEOPEN打开）将读取到这个对象中，OUT参数为完成读取后返回的CLOB类型对象。大小支持超过1GB，最大支持32TB。                                                                                                                                                                                                                                      |
  | src_file   | 需要读取的源BFILE文件。BFILE文件的大小支持超过1GB，最大支持32TB。                                                                                                                                                                                                                                                                                                  |
  | amount      | CLOB类型对象的长度，超过这个阈值的文件将不会保存到CLOB类型对象中。 说明： 长度小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                            |
  | dest_offset | CLOB类型对象的偏移长度。 说明： 偏移量小于1或者大于LOBMAXSIZE则报错。                                                                                                                                                                                                                                                 |
  | src_offset | BFILE文件的偏移长度。 说明： - 偏移量小于1或者大于LOBMAXSIZE则报错。  - amount + src_offset 大于 src_bfile的长度 + 1 则报错。   |
     
  
- DBE_LOB.CONVERTTOBLOB
  该函数将CLOB类型对象转换成BLOB类型对象，不支持大于1GB的场景。
  DBE_LOB.CONVERTTOBLOB原型为：
  ```
  DBE_LOB.CONVERTTOBLOB(
      dest_blob   IN BLOB,
      src_clob    IN CLOB,
      amount      IN INTEGER DEFAULT 32767,
      dest_offset IN INTEGER DEFAULT 1,
      src_offset  IN INTEGER DEFAULT 1)
  RETURN RAW;
  ```
  表35DBE_LOB.CONVERTTOBLOB接口参数说明 
  | 参数           | 说明                                                          |
  |:---|:---|
  | dest_blob   | 目标BLOB类型对象，CLOB类型对象转换后的文件。                                   |
  | src_clob  | 需要读取的源CLOB类型对象。                                             |
  | amount     | CLOB类型对象的长度，超过这个阈值的文件将不会保存到BLOB类型对象中。长度小于1或者大于LOBMAXSIZE则报错。 |
  | dest_offset  | BLOB类型对象的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。                |
  | src_offset | CLOB类型对象的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。                 |
     
  
- DBE_LOB.LOB_CONVERTTOBLOB
  该函数将CLOB类型对象转换成BLOB类型对象，支持LOB类型对象大于1GB。
  DBE_LOB.LOB_CONVERTTOBLOB原型为：
  ```
  DBE_LOB.LOB_CONVERTTOBLOB(
      dest_blob   INOUT BLOB,
      src_clob    IN    CLOB,
      amount      IN    BIGINT,
      dest_offset INOUT BIGINT,
      src_offset  INOUT BIGINT)
  ```
  表36DBE_LOB.LOB_CONVERTTOBLOB接口参数说明 
  | 参数          | 说明                                                                     |
  |:---|:---|
  | dest_blob   | 目标BLOB类型对象，CLOB类型对象转换后的文件。                                              |
  | src_clob   | 需要读取的源CLOB类型对象。                                                      |
  | amount       | CLOB类型对象的长度，超过这个阈值的文件将不会保存到BLOB类型对象中。长度小于1或者大于LOBMAXSIZE则报错。            |
  | dest_offset   | BLOB类型对象的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。偏移量小于1或者大于LOBMAXSIZE则报错。 |
  | src_offset | CLOB类型对象的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。偏移量小于1或者大于LOBMAXSIZE则报错。    |
     
  
- DBE_LOB.CONVERTTOCLOB
  该函数将BLOB类型对象转换成CLOB类型对象，不支持大于1GB的场景。
  DBE_LOB.CONVERTTOCLOB原型为：
  ```
  DBE_LOB.CONVERTTOCLOB(
      dest_clob   IN CLOB,
      src_blob    IN BLOB,
      amount      IN INTEGER DEFAULT 32767,
      dest_offset IN INTEGER DEFAULT 1,
      src_offset  IN INTEGER DEFAULT 1)
  RETURN text;
  ```
  表37DBE_LOB.CONVERTTOCLOB接口参数说明 
  | 参数           | 说明                                              |
  |:---|:---|
  | dest_clob  | 目标CLOB类型对象，BLOB类型对象转换后的文件。                     |
  | src_blob   | 需要读取的源BLOB类型对象。                              |
  | amount    | BLOB类型对象的长度，超过这个阈值的文件将不会保存到CLOB类型对象中。            |
  | dest_offset | CLOB类型对象的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。 |
  | src_offset    | BLOB类型对象的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。    |
     
  

- DBE_LOB.LOB_CONVERTTOCLOB
  该函数将BLOB类型对象转换成CLOB类型对象，支持LOB类型对象大于1G。
  DBE_LOB.LOB_CONVERTTOCLOB原型为：
  ```
  DBE_LOB.LOB_CONVERTTOCLOB(
      dest_clob    INOUT CLOB,
      src_blob    IN    BLOB,
      amount      IN    BIGINT,
      dest_offset INOUT BIGINT,
      src_offset  INOUT BIGINT)
  ```
  表38DBE_LOB.LOB_CONVERTTOCLOB接口参数说明 
  | 参数         | 说明                                                                 |
  |:---|:---|
  | dest_clob   | 目标CLOB类型对象，BLOB类型对象转换后的文件。                                           |
  | src_blob     | 需要读取的源BLOB类型对象。                                                       |
  | amount     | BLOB类型对象的长度，超过这个阈值的文件将不会保存到CLOB类型对象中。                                  |
  | dest_offset | CLOB类型对象的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。偏移量小于1或者大于LOBMAXSIZE则报错。 |
  | src_offset | BLOB类型对象的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。偏移量小于1或者大于LOBMAXSIZE则报错。 |
     
  
- DBE_LOB.GETCHUNKSIZE
  在数据库存储LOB类型对象时，内部使用toast存储，本函数返回TOAST_MAX_CHUNK_SIZE。
  DBE_LOB.GETCHUNKSIZE的原型为：
  ```
  DBE_LOB.GETCHUNKSIZE(
      lob_loc IN CLOB
  )RETURN INTEGER
  DBE_LOB.GETCHUNKSIZE(
      lob_loc IN BLOB
  )RETURN INTEGER
  ```
  表39DBE_LOB.GETCHUNKSIZE接口参数说明 
  | 参数       | 说明                     |
  |:---|:---|
  | lob_loc | 目标CLOB类型对象/BLOB类型对象。 |
     
  
- DBE_LOB.LOB_WRITE
  将源对象从起始位置读取指定长度内容，写入目标LOB类型对象的指定偏移位置，覆盖该位置原内容, 并返回目标LOB类型对象。
  DBE_LOB.LOB_WRITE原型为：
  ```
  DBE_LOB.LOB_WRITE(
      clob_obj INOUT CLOB,
      amount   IN    INTEGER,
      off_set  IN    BIGINT,
      source   IN    VARCHAR2 
  )
  RETURN CLOB;
  DBE_LOB.LOB_WRITE(
      blob_obj INOUT BLOB,
      amount   IN    INTEGER,
      off_set  IN    BIGINT,
      source   IN    RAW
  )
  RETURN BLOB;
  ```
  表40DBE_LOB.LOB_WRITE接口参数说明 
  | 参数                 | 类型          | 入参/出参 | 是否可以为空 | 描述                                    |
  |:---|:---|:---|:---|:---|
  | blob_obj/clob_obj | BLOB/CLOB    | INOUT  | 否      | IN参数为待写入的目标LOB类型对象，OUT参数为写入内容后的LOB类型对象。 |
  | amount              | INTEGER        | IN   | 否       | 待写入的长度（BLOB类型对象以字节为单位，CLOB类型对象以字符为单位）。  |
  | off_set             | BIGINT      | IN      | 否        | 在blob_obj/clob_obj中写入的偏移位置。              |
  | source              | RAW/VARCHAR2 | IN    | 否      | 源对象。                                    |
     
  

- DBE_LOB.BFILENAME
  该函数用于根据目录和文件名构造BFILE文件。
  DBE_LOB.BFILENAME原型为：
  ```
  DBE_LOB.BFILENAME(
      directory IN TEXT,
      filename  IN TEXT)
  RETURN DBE_LOB.BFILE;
  ```
  表41DBE_LOB.BFILENAME接口参数说明 
  | 参数         | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  |:---|:---|
  | directory | 文件目录。 说明： 文件目录的位置，需要添加到系统表[PG_DIRECTORY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0983.html)中，如果传入的路径和[PG_DIRECTORY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0983.html)中的路径不匹配，会报路径不存在的错误。 - 在打开GUC参数safe_data_path时，用户只能通过高级包读写safe_data_path指定文件路径下的文件。  - 文件名，包含扩展（文件类型），不包括路径名。如果文件名中包含路径，在OPEN中会被忽略，在Unix系统中，文件名不能以/.结尾。   |
  | filename   | 文件名。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
     
  
 
#### 示例
```
-- 获取字符串的长度。
SELECT DBE_LOB.GET_LENGTH('12345678');
 get_length 
------------
          8
(1 row)
-- DBE_LOB.READ接口示例。
DECLARE
myraw  RAW(100);
amount INTEGER :=2;
buffer INTEGER :=1;
begin
DBE_LOB.READ('123456789012345',amount,buffer,myraw);
dbe_output.print_line(myraw);
end;
/
0123
ANONYMOUS BLOCK EXECUTE
CREATE TABLE blob_Table (t1 blob) DISTRIBUTE BY REPLICATION;
CREATE TABLE blob_Table_bak (t2 blob) DISTRIBUTE BY REPLICATION;
INSERT INTO blob_Table VALUES('abcdef');
INSERT INTO blob_Table_bak VALUES('22222');
-- DBE_LOB多接口示例。
DECLARE
str varchar2(100) := 'abcdef';
source raw(100);
dest blob;
copyto blob;
amount int;
PSV_SQL varchar2(100);
PSV_SQL1 varchar2(100);
a int :=1;
len int;
BEGIN
source := dbe_raw.cast_from_varchar2_to_raw(str);
amount := dbe_raw.get_length(source);
PSV_SQL :='select * from blob_Table for update';
PSV_SQL1 := 'select * from blob_Table_bak for update';
EXECUTE IMMEDIATE PSV_SQL into dest;
EXECUTE IMMEDIATE PSV_SQL1 into copyto;
DBE_LOB.WRITE(dest, amount, 1, source);
DBE_LOB.WRITE_APPEND(dest, amount, source);
DBE_LOB.ERASE(dest, a, 1);
DBE_OUTPUT.PRINT_LINE(a);
DBE_LOB.COPY(copyto, dest, amount, 10, 1);
perform DBE_LOB.CLOSE(dest);
RETURN;
END;
/
1
ANONYMOUS BLOCK EXECUTE
-- 删除表。
DROP TABLE blob_Table;
DROP TABLE blob_Table_bak;
```
