[BUGFIX] fix lob bugs

src/share/ob_lob_access_utils.cpp

@@ -1133,7 +1133,7 @@ int ObTextStringResult::fill(int64_t pos, int c, int64_t len)
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("Lob: append content length too long", K(this), K(pos), K(len), K(ret));
     } else {
-      MEMSET(buffer_ + pos, c, len);
+      MEMSET(buffer_ + pos_ + pos, c, len);
     }
   } else {
     ret = OB_NOT_IMPLEMENT;

src/sql/engine/expr/ob_expr_instr.cpp

@@ -148,7 +148,9 @@ static int calc_oracle_instr_text(ObTextStringIter &haystack_iter,
     LOG_WARN("get needle data failed ", K(ret), K(needle_iter));
   } else if (OB_FAIL(needle_iter.get_char_len(needle_char_len))) {
     LOG_WARN("get needle char len failed ", K(ret), K(needle_iter));
-  } else if (haystack_char_len - abs_pos_int < needle_char_len) {
+  } else if ((needle_char_len < 1) ||
+             (haystack_char_len - abs_pos_int + 1 < needle_char_len)) {
+    // pattern is empty string, just return zero
     // pattern length is bigger than content, just return zero
     idx = 0;
   } else {

src/storage/lob/ob_lob_manager.cpp

@@ -2298,9 +2298,9 @@ int ObLobManager::write_outrow_inner(ObLobAccessParam& param, ObLobQueryIter *it
       // prepare write iter
       ObLobMetaWriteIter write_iter(read_buf, param.allocator_, ObLobMetaUtil::LOB_OPER_PIECE_DATA_SIZE);
       if (OB_FAIL(write_iter.open(param, iter, read_buf, padding_size, post_data, remain_buf, seq_id_st, seq_id_ed))) {
-        LOG_WARN("failed to open meta writer", K(ret));
+        LOG_WARN("failed to open meta writer", K(ret), K(write_iter), K(meta_iter), K(found_begin), K(found_end));
       } else if (OB_FAIL(write_outrow_result(param, write_iter))) {
-        LOG_WARN("failed to write outrow result", K(ret));
+        LOG_WARN("failed to write outrow result", K(ret), K(write_iter), K(meta_iter), K(found_begin), K(found_end));
       }
       write_iter.close();
     }
@@ -2810,7 +2810,11 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
     ObLobMetaInfo new_meta_row = result.meta_result_.info_;
     char* tmp_buf = tmp_buff.ptr();
     ObString read_data;
+    if (param.is_fill_zero_) {
       read_data.assign_buffer(tmp_buf, result.meta_result_.info_.byte_len_);
+    } else {
+      read_data = result.meta_result_.info_.lob_data_;
+    }
 
     // save variable
     uint32_t tmp_st = result.meta_result_.st_;
@@ -2822,7 +2826,7 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
     if (OB_ISNULL(tmp_buf)) {
       ret = OB_ERR_UNEXPECTED;
       LOG_WARN("tmp buffer is null.", K(ret), K(tmp_buff));
-    } else if (OB_FAIL(get_real_data(param, result, read_data))) {
+    } else if (param.is_fill_zero_ && OB_FAIL(get_real_data(param, result, read_data))) {
       LOG_WARN("failed to write data to read buf.", K(ret), K(result));
     } else {
       result.meta_result_.st_ = tmp_st;
@@ -2875,12 +2879,17 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
             fill_zero(read_data.ptr(), read_data.length(), is_char, by_len, by_st, fill_char_len);
             read_data.set_length(read_data.length() - by_len + fill_char_len);
             new_meta_row.byte_len_ = read_data.length();
+          } else {
+            read_data.assign_buffer(tmp_buf, result.meta_result_.info_.byte_len_);
+            if (OB_FAIL(get_real_data(param, result, read_data))) {
+              LOG_WARN("failed to write data to read buf.", K(ret), K(result));
             } else {
               new_meta_row.byte_len_ -= (by_len);
               new_meta_row.char_len_ -= (local_end - local_begin);
               MEMMOVE(read_data.ptr() + by_st, read_data.ptr() + (by_st + by_len), piece_byte_len - (by_st + by_len));
               read_data.assign_ptr(read_data.ptr(), read_data.length() - by_len);
             }
+          }
         } else {
           del_piece = true;
         }
@@ -2927,6 +2936,10 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
             fill_zero(read_data.ptr(), read_data.length(), is_char, by_len, 0, fill_char_len);
             read_data.set_length(fill_char_len + read_data.length() - by_len);
             new_meta_row.byte_len_ = read_data.length();
+          } else {
+            read_data.assign_buffer(tmp_buf, result.meta_result_.info_.byte_len_);
+            if (OB_FAIL(get_real_data(param, result, read_data))) {
+              LOG_WARN("failed to write data to read buf.", K(ret), K(result));
             } else {
               new_meta_row.char_len_ = piece_char_len - local_end;
               new_meta_row.byte_len_ = read_data.length() - by_len;
@@ -2935,6 +2948,7 @@ int ObLobManager::erase_process_meta_info(ObLobAccessParam& param, ObLobMetaScan
             }
           }
         }
+      }
 
       if (OB_FAIL(ret)) {
       } else if (del_piece) {

src/storage/lob/ob_lob_meta.cpp

@@ -306,8 +306,8 @@ int ObLobMetaWriteIter::open(ObLobAccessParam &param,
 int ObLobMetaWriteIter::open(ObLobAccessParam &param, ObILobApator* adatper)
 {
   int ret = OB_SUCCESS;
-  
+  bool is_empty_lob = (param.byte_size_ == 0);
-  if (OB_FAIL(scan_iter_.open(param, adatper))) {
+  if (!is_empty_lob && OB_FAIL(scan_iter_.open(param, adatper))) {
     LOG_WARN("failed open scan meta open iter.", K(ret));
   } else {
     coll_type_ = param.coll_type_;
@@ -315,9 +315,10 @@ int ObLobMetaWriteIter::open(ObLobAccessParam &param, ObILobApator* adatper)
     piece_id_ = ObLobMetaUtil::LOB_META_INLINE_PIECE_ID;
     padding_size_ = 0;
     inner_buffer_.assign_ptr(nullptr, 0);
-    ObLobMetaScanResult scan_res;
     
     // locate first piece
+    if (!is_empty_lob) {
+      ObLobMetaScanResult scan_res;
       ret = scan_iter_.get_next_row(scan_res);
       if (OB_FAIL(ret)) {
         if (ret == OB_ITER_END) {
@@ -331,6 +332,7 @@ int ObLobMetaWriteIter::open(ObLobAccessParam &param, ObILobApator* adatper)
         seq_id_.set_seq_id(scan_res.info_.seq_id_);
       }
     }
+  }
   return ret;
 }
 

src/storage/lob/ob_lob_meta.h

@@ -68,6 +68,7 @@ public:
   bool is_range_begin(const ObLobMetaInfo& info);
   bool is_range_end(const ObLobMetaInfo& info);
   bool is_range_over(const ObLobMetaInfo& info);
+  TO_STRING_KV(K_(cur_pos), K_(cur_info));
 private:
   bool is_in_range(const ObLobMetaInfo& info);
 private:
@@ -108,6 +109,8 @@ public:
            ObString &seq_id_end);
   int get_next_row(ObLobMetaWriteResult &row);
   int close();
+  TO_STRING_KV(K_(seq_id), K_(offset), K_(lob_id), K_(piece_id), K_(coll_type), K_(piece_block_size),
+               K_(scan_iter), K_(padding_size), K_(seq_id_end), K_(last_info));
 private:
   int try_fill_data(
       ObLobMetaWriteResult& row,

src/storage/lob/ob_lob_seq.cpp

@@ -14,6 +14,7 @@
 
 #include "ob_lob_seq.h"
 #include <netinet/in.h>
+#include "deps/oblib/src/lib/utility/ob_print_utils.h"
 
 namespace oceanbase
 {
@@ -400,5 +401,47 @@ int ObLobSeqId::parse()
   return ret;
 }
 
+int64_t ObLobSeqId::to_string(char* buf, const int64_t buf_len) const
+{
+  int64_t pos = 0;
+  J_OBJ_START();
+  ObString tmp_seq = seq_id_;
+  size_t len = tmp_seq.length();
+  uint32_t ori_len = static_cast<uint32_t>(len / sizeof(uint32_t)); //TODO(yuanzhi.zy): check is len int32 enough
+  uint32_t cur_pos = 0;
+  common::databuff_printf(buf, buf_len, pos, "seq_id:[");
+  while (cur_pos < ori_len && tmp_seq.ptr() != nullptr) {
+    uint32_t val = ObLobSeqId::load32be(tmp_seq.ptr() + sizeof(uint32_t) * cur_pos);
+    common::databuff_printf(buf, buf_len, pos, "%u.", val);
+    cur_pos++;
+  } // end while
+  common::databuff_printf(buf, buf_len, pos, "], ");
+  oceanbase::common::databuff_print_kv(buf, buf_len, pos, K_(read_only), K_(parsed));
+
+  common::databuff_printf(buf, buf_len, pos, ", seq_id_in_buff:[");
+  ori_len = static_cast<uint32_t>(len_ / sizeof(uint32_t));
+  cur_pos = 0;
+  while (cur_pos < ori_len && buf_ != nullptr) {
+    uint32_t val = ObLobSeqId::load32be(buf_ + sizeof(uint32_t) * cur_pos);
+    common::databuff_printf(buf, buf_len, pos, "%u.", val);
+    cur_pos++;
+  } // end while
+  common::databuff_printf(buf, buf_len, pos, "], ");
+  oceanbase::common::databuff_print_kv(buf, buf_len, pos, K_(len), K_(cap));
+
+  common::databuff_printf(buf, buf_len, pos, ", seq_id_in_digits:[");
+  ori_len = dig_len_;
+  cur_pos = 0;
+  while (cur_pos < ori_len && digits_ != nullptr) {
+    common::databuff_printf(buf, buf_len, pos, "%u.", digits_[cur_pos]);
+    cur_pos++;
+  } // end while
+  common::databuff_printf(buf, buf_len, pos, "], ");
+  oceanbase::common::databuff_print_kv(buf, buf_len, pos, K_(dig_len), K_(dig_cap));
+
+  J_OBJ_END();
+  return pos;
+}
+
 } // storage
 } // oceanbase

src/storage/lob/ob_lob_seq.h

@@ -43,6 +43,7 @@ public:
   void reset();
   static char* store32be(char *ptr, uint32_t val);
   static uint32_t load32be(const char *ptr);
+  int64_t to_string(char* buf, const int64_t buf_len) const;
 private:
   int init_digits();
   int init_seq_buf();