# DBE_LOB
#### 接口介绍
高级功能包DBE_LOB支持的所有接口参见[表1]。
 表1DBE_LOB 
| 接口名称                                                                                                                                         | 描述                                   |
|:---|:---|
| [DBE_LOB.GET_LENGTH]   | 获取并返回指定的LOB类型对象的长度。                  |
| [DBE_LOB.OPEN]                                                  | 打开一个LOB返回一个LOB的描述符。                  |
| [DBE_LOB.READ]         | 根据指定的长度及起始位置偏移读取LOB内容的一部分到BUFFER缓冲区。 |
| [DBE_LOB.WRITE]        | 根据指定长度及起始位置偏移将BUFFER中内容写入到LOB中。      |
| [DBE_LOB.WRITE_APPEND] | 根据指定长度将BUFFER中内容写入到LOB的尾部。           |
| [DBE_LOB.COPY]         | 根据指定长度及起始位置偏移将BLOB内容写入到另一个BLOB中。     |
| [DBE_LOB.ERASE]        | 根据指定长度及起始位置偏移删除BLOB中的内容。             |
| [DBE_LOB.CLOSE]        | 关闭已经打开的LOB描述符。                       |
| [DBE_LOB.MATCH]                                                 | 返回一个字符串在LOB中第N次出现的位置。                |
| [DBE_LOB.COMPARE]                                              | 比较两个LOB或者两个LOB的某一部分。                 |
| [DBE_LOB.SUBSTR]                                                 | 用于读取一个LOB的子串，返回读取的字节个数或者字符个数。        |
| [DBE_LOB.STRIP]                                                  | 用于截断指定长度的LOB，执行完会将LOB的长度设置为参数指定的长度。  |
| [DBE_LOB.CREATE_TEMPORARY]                                       | 创建一个临时的BLOB或者CLOB对象。                 |
| [DBE_LOB.APPEND]                                                 | 将源LOB的内容拼接到目的LOB中。                   |
| [DBE_LOB.FREETEMPORARY]                                           | 删除一个临时的BLOB或者CLOB对象。                 |
| [DBE_LOB.FILEOPEN]                                              | 打开一个数据库外部文件，并返回文件表述符。                |
| [DBE_LOB.FILECLOSE]                                              | 关闭由FILEOPEN打开的外部文件。                  |
| [DBE_LOB.LOADFROMFILE]                                          | 读取数据库外部文件到BLOB文件中。                   |
| [DBE_LOB.LOADBLOBFROMFILE]                                      | 读取数据库外部文件到BLOB文件中。                   |
| [DBE_LOB.LOADCLOBFROMFILE]                                      | 读取数据库外部文件到CLOB文件中。                   |
| [DBE_LOB.CONVERTTOBLOB]                                         | 将CLOB类型文件转换为BLOB类型文件。                |
| [DBE_LOB.CONVERTTOCLOB]                                          | 将BLOB类型文件转换为CLOB类型文件。                |
   
- DBE_LOB.GET_LENGTH
  存储过程GET_LENGTH获取并返回指定的LOB类型对象的长度，最大支持2GB。
  DBE_LOB.GET_LENGTH函数原型为：
  ```
  DBE_LOB.GET_LENGTH (
  lob    IN   BLOB)
  RETURN INTEGER;
  DBE_LOB.GET_LENGTH (
  lob    IN   CLOB)
  RETURN INTEGER;
  ```
  表2DBE_LOB.GET_LENGTH接口参数说明 
  | 参数  | 描述                   |
  |:---|:---|
  | lob | 待获取长度的BLOB/CLOB类型对象。 |
     
  
- DBE_LOB.OPEN
  存储过程打开一个LOB，并返回一个LOB描述符，该过程无实际意义，仅用于兼容。
  DBE_LOB.OPEN函数原型为：
  ```
  DBE_LOB.OPEN (
  lob    INOUT   BLOB
  );
  DBE_LOB.OPEN (
  lob  INOUT    CLOB
  );
  DBE_LOB.OPEN (
  bfile dbe_lob.bfile,
  open_mode text DEFAULT 'null'::text
  );
  ```
  表3DBE_LOB.OPEN接口参数说明 
  | 参数  | 描述                |
  |:---|:---|
  | lob | 被打开的BLOB或者CLOB对象。 |
     
  
- DBE_LOB.READ
  存储过程READ根据指定长度及起始位置偏移读取LOB内容的一部分到BUFFER缓冲区。
  DBE_LOB.READ函数原型为：
  ```
  DBE_LOB.READ (
  lob     IN     BLOB,
  len     IN     INTEGER,
  start   IN     INTEGER,
  buffer  OUT    RAW);
  DBE_LOB.READ (
  lob     IN     CLOB,
  len     INOUT  INTEGER,
  start   IN     INTEGER,
  buffer  OUT    VARCHAR2);
  ```
  表4DBE_LOB.READ接口参数说明 
  | 参数     | 说明                                                                                                                                                                                                                                                                                            |
  |:---|:---|
  | lob    | 待读入的BLOB/CLOB类型对象。                                                                                                                                                                                                                                                                            |
  | len    | 读入长度，最大支持32767字符。 说明： 如果读入长度为负，会收到错误提示"ERROR: argument 2 is null, invalid, or out of range." |
  | start  | 指定从LOB内容的哪个位置开始读取的偏移（即相对LOB内容起始位置的字节数）。                                                                                                                                                                                                                                                       |
  | buffer | 读取LOB内容后存放的目标缓冲区。                                                                                                                                                                                                                                                                             |
     
  其中，lob支持超过1GB的clob类型，最大支持2GB，buffer最大支持32k，不能大于len的长度。
  
- DBE_LOB.WRITE
  存储过程WRITE根据指定长度及起始位置将BUFFER中内容写入到LOB变量中。
  DBE_LOB.WRITE函数原型为：
  ```
  DBE_LOB.WRITE (
  dest_lob   INOUT    BLOB,
  len        IN       INTEGER,
  start      IN       INTEGER,
  src_lob    IN       RAW);
  DBE_LOB.WRITE (
  dest_lob   INOUT   CLOB,
  len        IN       INTEGER,
  start      IN       INTEGER,
  src_lob    IN       VARCHAR2);
  ```
  表5DBE_LOB.WRITE接口参数说明 
  | 参数       | 说明                                                                                                                                                                                                                                                                                                                           |
  |:---|:---|
  | dest_lob | 待写入的BLOB/CLOB类型对象。                                                                                                                                                                                                                                                                                                           |
  | len      | 写入长度，最大支持32767字符。 说明： 如果写入长度小于1或写入长度大于待写入的内容长度，则报错。                              |
  | start    | 指定从LOB内容的哪个位置开始写入的偏移（即相对LOB内容起始位置的字节数）。 说明： 如果偏移量小于1，则报错；如果偏移量大于LOB类型最大长度时，不会报错。 |
  | src_lob  | 待写入的内容。                                                                                                                                                                                                                                                                                                                      |
     
  其中，dest_lob支持超过1GB的clob类型，最大支持2GB，src_lob最大支持1GB，不能超过1GB。
  
- DBE_LOB.WRITE_APPEND
  存储过程WRITE_APPEND根据指定长度将BUFFER中内容写入到LOB的尾部。
  DBE_LOB.WRITE_APPEND函数原型为：
  ```
  DBE_LOB.WRITE_APPEND (
  dest_lob    INOUT    BLOB,
  len         IN        INTEGER,
  src_lob     IN        RAW);
  DBE_LOB.WRITE_APPEND (
  dest_lob    INOUT     CLOB,
  len         IN        INTEGER,
  src_lob     IN        VARCHAR2);
  ```
  表6DBE_LOB.WRITE_APPEND接口参数说明 
  | 参数       | 说明                                                                                                                                                                                                                                                                                              |
  |:---|:---|
  | dest_lob | 待写入的指定BLOB/CLOB类型对象。                                                                                                                                                                                                                                                                            |
  | len      | 写入长度，最大支持32767字符。 说明： 如果写入长度小于1或写入长度大于待写入的内容长度，则报错。 |
  | src_lob  | 待写入的内容。                                                                                                                                                                                                                                                                                         |
     
  
- DBE_LOB.COPY
  存储过程COPY根据指定长度及起始位置偏移将BLOB内容拷贝到另一个BLOB中。
  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);
  ```
  表7DBE_LOB.COPY接口参数说明 
  | 参数         | 说明                                                                                                                                                                                                                                                                                                                       |
  |:---|:---|
  | dest_lob   | 待拷入的BLOB类型对象。                                                                                                                                                                                                                                                                                                            |
  | src_lob    | 待拷出的BLOB类型对象。                                                                                                                                                                                                                                                                                                            |
  | len        | 拷贝长度。 说明： 如果拷入长度小于1或拷入长度大于BLOB类型最大长度，则报错。                                    |
  | dest_start | 指定从BLOB内容的哪个位置开始拷入的偏移（即相对BLOB内容起始位置的字节数）。 说明： 如果偏移量小于1或偏移量大于BLOB类型最大长度，则报错。  |
  | src_start  | 指定从BLOB内容的哪个位置开始拷出的偏移（即相对BLOB内容起始位置的字节数）。 说明： 如果偏移量小于1或偏移量大于拷贝来源BLOB的长度，则报错。 |
     
  
- DBE_LOB.ERASE
  存储过程ERASE根据指定长度及起始位置偏移删除BLOB中的内容。
  DBE_LOB.ERASE函数原型为：
  ```
  DBE_LOB.ERASE (
  lob        INOUT   BLOB,
  len        INOUT   INTEGER,
  start      IN      INTEGER DEFAULT 1);
  ```
  表8DBE_LOB.ERASE接口参数说明 
  | 参数    | 说明                                                                                                                                                                                                                                                                                                                      |
  |:---|:---|
  | lob   | 待删除内容的BLOB类型对象。                                                                                                                                                                                                                                                                                                         |
  | len   | 待删除的长度。 说明： 如果删除长度小于1或删除长度大于BLOB类型最大长度，则报错。                                 |
  | start | 指定从BLOB内容的哪个位置开始删除的偏移（即相对BLOB内容起始位置的字节数）。 说明： 如果偏移量小于1或偏移量大于BLOB类型最大长度，则报错。 |
     
  
- 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);
  ```
  表9DBE_LOB.CLOSE接口参数说明 
  | 参数  | 说明                 |
  |:---|:---|
  | lob | 待关闭的BLOB/CLOB类型对象。 |
     
  
- DBE_LOB.MATCH
  该函数返回pattern在LOB中第N次出现的位置，如果输入的是一些无效值会返回NULL值。offset \< 1 or offset \> LOBMAXSIZE，nth \< 1，nth \> LOBMAXSIZE。
  DBE_LOB.MATCH函数原型为：
  ```
  DBE_LOB.MATCH (
  lob              IN     BLOB,
  pattern          IN     RAW,
  start_index      IN     INTEGER  DEFAULT 1,
  match_index      IN     INTEGER  DEFAULT 1)
  RETURN INTEGER;
  DBE_LOB.MATCH (
  lob              IN     CLOB,
  pattern          IN     VARCHAR2 ,
  start_index      IN     INTEGER  DEFAULT 1,
  match_index      IN     INTEGER  DEFAULT 1)
  RETURN INTEGER;
  ```
  表10DBE_LOB.match接口参数说明 
  | 参数          | 说明                                                 |
  |:---|:---|
  | lob         | 要查找的BLOB/CLOB描述符。                                  |
  | pattern     | 要匹配的模式，对于BLOB是由一组RAW类型的数据组成，对于CLOB是由一组text类型的数据组成。 |
  | start_index | 对于BLOB是以字节为单位的绝对偏移量，对于CLOB是以字符为单位的偏移量，模式匹配的起始位置是1。 |
  | match_index | 模式匹配的次数，最小值为1。                                     |
     
  
- DBE_LOB.COMPARE
  这个函数比较两个LOB或者两个LOB的一部分。
  - 如果比较的结果相等返回0，否则返回非零的值。
  
  - 如果第一个LOB比第二个小，返回-1；如果第一个LOB比第二个大，返回1。
  
  - 如果len，start1，start2这几个参数有无效参数返回NULL，有效的偏移量范围是1\~LOBMAXSIZE。
  
  
  DBE_LOB.COMPARE函数原型为：
  ```
  DBE_LOB.COMPARE (
  lob1     IN     BLOB,
  lob2     IN     BLOB,
  len      IN     INTEGER DEFAULT DBE_LOB.LOBMAXSIZE,
  start1   IN     INTEGER DEFAULT 1,
  start2   IN     INTEGER DEFAULT 1)
  RETURN INTEGER;
  DBE_LOB.COMPARE (
  lob1     IN     CLOB,
  lob2     IN     CLOB,
  len      IN     INTEGER DEFAULT DBE_LOB.LOBMAXSIZE,
  start1   IN     INTEGER DEFAULT 1,
  start2   IN     INTEGER DEFAULT 1)
  RETURN INTEGER;
  ```
  表11DBE_LOB.COMPARE接口参数说明 
  | 参数     | 说明                                   |
  |:---|:---|
  | lob1   | 第一个要比较的BLOB/CLOB类型对象。                |
  | lob2   | 第二个要比较的BLOB/CLOB类型对象。                |
  | len    | 要比较的字符数或者字节数，最大值为DBE_LOB.LOBMAXSIZE。 |
  | start1 | 第一个LOB描述符的偏移量，初始位置是1。                |
  | start2 | 第二个LOB描述符的偏移量，初始位置是1。                |
     
  
- DBE_LOB.SUBSTR
  用于读取一个LOB的子串，返回读取的字节个数或者字符个数，amount \<1或者amount \>32767，offset \< 1或者offset \> LOBMAXSIZE的时候返回值是NULL。
  DBE_LOB.SUBSTR函数原型为：
  ```
  DBE_LOB.SUBSTR (
  lob        IN     BLOB,
  len        IN     INTEGER DEFAULT  32767,
  start      IN     INTEGER DEFAULT  1)
  RETURN RAW;
  DBE_LOB.SUBSTR (
  lob        IN     CLOB,
  len        IN     INTEGER DEFAULT  32767,
  start      IN     INTEGER DEFAULT  1)
  RETURN VARCHAR2;
  ```
  表12DBE_LOB.SUBSTR接口参数说明 
  | 参数    | 说明                                                    |
  |:---|:---|
  | lob   | 将要读取子串的LOB描述符，对于BLOB类型的返回值是读取的字节个数，对于CLOB类型的返回值是字符个数。 |
  | len   | 要读取的字节数或者字符数量。                                        |
  | start | 从开始位置偏移的字符数或者字节数量。                                    |
     
  
- DBE_LOB.STRIP
  这个存储过程用于截断指定长度的LOB，执行完这个存储过程会将LOB的长度设置为newlen参数指定的长度。如果对一个空的LOB执行截断操作，不会有任何执行结果；如果指定的长度比LOB的长度长，会产生一个异常。
  DBE_LOB.STRIP函数原型为：
  ```
  DBE_LOB.STRIP (
  lob       IN OUT     BLOB,
  newlen    IN       INTEGER);
  DBE_LOB.STRIP (
  lob       IN OUT     CLOB,
  newlen    IN        INTEGER);
  ```
  表13DBE_LOB.STRIP接口参数说明 
  | 参数     | 说明                                |
  |:---|:---|
  | lob    | 待读入的指定BLOB类型对象。                   |
  | newlen | 截断后LOB的新长度，对于BLOB是字节数，对于CLOB是字符数。 |
     
  
- DBE_LOB.CREATE_TEMPORARY
  这个存储过程创建一个临时的BLOB或者CLOB，这个存储过程仅用于语法上的兼容，并无实际意义。
  DBE_LOB.CREATE_TEMPORARY函数原型为：
  ```
  DBE_LOB.CREATE_TEMPORARY (
  locator           INOUT      BLOB,
  cache             IN         BOOLEAN,
  keep_alive_time   IN         INTEGER);
  DBE_LOB.CREATE_TEMPORARY (
  locator           INOUT      CLOB,
  cache             IN         BOOLEAN,
  keep_alive_time   IN         INTEGER);
  ```
  表14DBE_LOB.CREATE_TEMPORARY接口参数说明 
  | 参数              | 说明         |
  |:---|:---|
  | locator         | LOB描述符。    |
  | cache           | 仅用于语法上的兼容。 |
  | keep_alive_time | 仅用于语法上的兼容。 |
     
  
- DBE_LOB.APPEND
  存储过程APPEND根据指定长度及起始位置偏移读取BLOB内容的一部分到BUFFER缓冲区。
  DBE_LOB.APPEND函数原型为：
  ```
  DBE_LOB.APPEND (
  dest_lob    INOUT       BLOB,
  src_lob     IN          BLOB);
  DBE_LOB.APPEND (
  dest_lob    INOUT       CLOB,
  src_lob     IN          CLOB);
  ```
  表15DBE_LOB.APPEND接口参数说明 
  | 参数       | 说明               |
  |:---|:---|
  | dest_lob | 要写入的BLOB/CLOB对象。 |
  | src_lob  | 读取的BLOB/CLOB对象。  |
     
  其中，dest_lob支持超过1GB的clob类型，最大支持2GB，src_lob最大支持1GB，不能超过1GB。
  
- DBE_LOB.FREETEMPORARY
  存储过程用于释放由CREATE_TEMPORARY创建的LOB文件。
  DBE_LOB.FREETEMPORARY函数原型为：
  ```
  DBE_LOB.FREETEMPORARY (
  lob_loc    INOUT       BLOB);
  DBE_LOB.FREETEMPORARY (
  lob_loc    INOUT       CLOB);
  ```
  表16DBE_LOB.FREETEMPORARY接口参数说明 
  | 参数      | 说明               |
  |:---|:---|
  | lob_loc | 要释放的BLOB/CLOB对象。 |
     
  
- DBE_LOB.FILEOPEN
  这个函数用于打开数据库外部BFILE类型文件，并返回这个文件对用的文件描述符（fd）。
  BFILE类型定义为：
  ```
  DBE_LOB.BFILE (
  directory    text,
  filename     text);
  ```
  DBE_LOB.FILEOPEN函数原型为：
  ```
  DBE_LOB.FILEOPEN (
  file          IN    DBE_LOB.BFILE,
  open_mode     IN    text)
  RETURN integer;
  ```
  表17DBE_LOB.FILEOPEN接口参数说明 
  | 参数        | 说明                               |
  |:---|:---|
  | file      | 要打开的数据库外部文件（BFILE类型包含了文件路径和文件名）。 |
  | open_mode | 文件打开模式（w、r、a）。                   |
     
  
- DBE_LOB.FILECLOSE
  这个函数用于关闭数据外部BFILE类型文件。
  DBE_LOB.FILECLOSE函数原型为：
  ```
  DBE_LOB.FILECLOSE (
  file     IN    integer);
  ```
  表18DBE_LOB.FILECLOSE接口参数说明 
  | 参数   | 说明                              |
  |:---|:---|
  | file | 要关闭的数据库外部文件（由FILEOPEN返回的文件描述符）。 |
     
  
- DBE_LOB.LOADFROMFILE
  用于将BFILE类型外部文件读取到BLOB文件中。
  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;
  ```
  表19DBE_LOB.LOADFROMFILE接口参数说明 
  | 参数          | 说明                                          |
  |:---|:---|
  | dest_lob    | 目标blob文件，bfile文件将读取到这个文件中。                  |
  | src_bfile   | 需要读取的源bfile文件。                              |
  | amount      | blob文件的长度，超过这个阈值的文件将不会保存到blob中。             |
  | dest_offset | blob文件的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。 |
  | src_offset  | bfile文件的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。 |
     
  可以导入文件的大小可以超过1GB，amount的最大值为LOBMAXSIZE(4GB)，当src_offset或者dest_offset \> LOBMAXSIZE，以及amount \> LOBMAXSIZE时，高级包会报错。
  
- DBE_LOB.LOADBLOBFROMFILE
  用于将BFILE类型外部文件读取到BLOB文件中。
  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;
  ```
  表20DBE_LOB.LOADBLOBFROMFILE接口参数说明 
  | 参数          | 说明                                          |
  |:---|:---|
  | dest_lob    | 目标blob文件，bfile文件将读取到这个文件中。                  |
  | src_bfile   | 需要读取的源bfile文件。                              |
  | amount      | blob文件的长度，超过这个阈值的文件将不会保存到blob中。             |
  | dest_offset | blob文件的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。 |
  | src_offset  | bfile文件的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。 |
     
  
- DBE_LOB.LOADCLOBFROMFILE
  用于将BFILE类型外部文件读取到CLOB文件中。
  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;
  ```
  表21DBE_LOB.LOADCLOBFROMFILE接口参数说明 
  | 参数          | 说明                                          |
  |:---|:---|
  | dest_lob    | 目标clob文件，bfile文件将读取到这个文件中。                  |
  | src_bfile   | 需要读取的源bfile文件。                              |
  | amount      | clob文件的长度，超过这个阈值的文件将不会保存到clob中。             |
  | dest_offset | clob文件的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。 |
  | src_offset  | bfile文件的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。 |
     
  
- DBE_LOB.CONVERTTOBLOB
  这个函数将clob文件转换成blob文件。
  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;
  ```
  表22DBE_LOB.CONVERTTOBLOB接口参数说明 
  | 参数          | 说明                                          |
  |:---|:---|
  | dest_lob    | 目标blob文件，clob转换后的文件。                        |
  | src_bfile   | 需要读取的源clob文件。                               |
  | amount      | blob文件的长度，超过这个阈值的文件将不会保存到blob中。             |
  | dest_offset | blob文件的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。 |
  | src_offset  | clob文件的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。  |
     
  
- DBE_LOB.CONVERTTOCLOB
  这个函数将blob文件转换成clob文件。
  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;
  ```
  表23DBE_LOB.CONVERTTOCLOB接口参数说明 
  | 参数          | 说明                                          |
  |:---|:---|
  | dest_lob    | 目标clob文件，blob转换后的文件。                        |
  | src_bfile   | 需要读取的源blob文件。                               |
  | amount      | clob文件的长度，超过这个阈值的文件将不会保存到clob中。             |
  | dest_offset | clob文件的偏移长度，dest_offset=1将从文件起始位置开始载入，以此类推。 |
  | src_offset  | blob文件的偏移长度，src_offset=1将从文件起始位置开始读取，以此类推。  |
     
  
 
#### 示例
```
--获取字符串的长度
SELECT DBE_LOB.GET_LENGTH('12345678');
 get_length 
------------
          8
(1 row)
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');
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;
/
--删除表
DROP TABLE blob_Table;
DROP TABLE
DROP TABLE blob_Table_bak;
DROP TABLE
```