
# DBE_LOB
#### 接口介绍
高级功能包DBE_LOB支持的所有接口参见[表1]。
![](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- A数据库中空格的实际字节内容为00，GaussDB中空格对应字节内容为ASCII码值(32)。
- 集中式环境中，clob、blob以及bfile最大支持32TB。
- LOBMAXSIZE最大支持1073741771字节。
 
 表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的哪一个位置开始读取的偏移（即相对lob内容起始位置的字节数）。如果偏移量小于1或者大于lob长度，则报错。初始位置为1。                                                                                                                                         |
  | out_put                 | 读取参数lob内容后存放的目标缓冲区。                                                                                                                                                                                           |
     
  
- 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_obj/clob_obj的哪一个位置开始写入的偏移（即相对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/文件类型对象。 |
     
  
- 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
  这个存储过程用于截断指定长度的LOB，执行完这个存储过程会将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，执行完这个存储过程会将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
  这个存储过程创建一个临时的BLOB或者CLOB，这个存储过程仅用于语法上的兼容，并无实际意义。
  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
  存储过程用于释放由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
  这个函数用于打开数据库外部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））。 说明： file变量中包含文件目录的位置directory，文件名filename。 - 文件目录的位置，需要添加到系统表[20.2.57-PG_DIRECTORY](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-42-0916.html#ZH-CN_TOPIC_0000002559108257)中，如果传入的路径和[20.2.57-PG_DIRECTORY](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-42-0916.html#ZH-CN_TOPIC_0000002559108257)中的路径不匹配，会报路径不存在的错误。  - 在打开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
  这个存储过程用于打开数据库外部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文件。 说明： bfile变量中包含文件目录的位置directory，文件名filename。 - 文件目录的位置，需要添加到系统表[20.2.57-PG_DIRECTORY](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-42-0916.html#ZH-CN_TOPIC_0000002559108257)中，如果传入的路径和[20.2.57-PG_DIRECTORY](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-42-0916.html#ZH-CN_TOPIC_0000002559108257)中的路径不匹配，会报路径不存在的错误。  - 在打开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, 1, 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
  这个存储过程用于将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
  这个存储过程用于将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
  这个存储过程用于将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 | 文件目录 说明： 文件目录的位置，需要添加到系统表[20.2.57-PG_DIRECTORY](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-42-0916.html#ZH-CN_TOPIC_0000002559108257)中，如果传入的路径和[20.2.57-PG_DIRECTORY](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-42-0916.html#ZH-CN_TOPIC_0000002559108257)中的路径不匹配，会报路径不存在的错误。 - 在打开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);
CREATE TABLE blob_Table_bak (t2 blob);
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;
```
