[BUGFIX] fix lob text iter get next return err code

src/share/ob_lob_access_utils.cpp

@@ -560,7 +560,7 @@ ObTextStringIterState ObTextStringIter::get_next_block(ObString &str)
   str.reset();
   if (!is_init_ || state_ < TEXTSTRING_ITER_INIT) {
     state_ = TEXTSTRING_ITER_INVALID;
-    COMMON_LOG(WARN, "Lob: iter not initiated", K(ret));
+    COMMON_LOG(WARN, "Lob: iter not initiated", K(ret), K(*this));
   } else if (!is_lob_ || !is_outrow_ || !has_lob_header_) { // if not outrow lob, get full data
     switch (state_) {
       case TEXTSTRING_ITER_INIT: {
@@ -592,12 +592,13 @@ ObTextStringIterState ObTextStringIter::get_next_block(ObString &str)
       }
     }
   } else {
-    COMMON_LOG(WARN, "Lob: error case in of iter", K(*this));
+    COMMON_LOG(WARN, "Lob: error case in of iter", K(ret), K(*this));
     state_ = TEXTSTRING_ITER_INVALID;
   }
   if (OB_FAIL(ret)) {
-    COMMON_LOG(WARN, "Lob: iter get_next_block failed", K(*this));
+    COMMON_LOG(WARN, "Lob: iter get_next_block failed", K(ret), K(*this));
     state_ = TEXTSTRING_ITER_INVALID;
+    err_ret_ = ret;
   }
   return state_;
 }

src/share/ob_lob_access_utils.h

@@ -115,7 +115,8 @@ public:
   ObTextStringIter(ObObjType type, ObCollationType cs_type, const ObString &datum_str,
                    bool has_lob_header) :
     type_(type), cs_type_(cs_type), is_init_(false), is_lob_(false), is_outrow_(false),
-    has_lob_header_(has_lob_header), state_(TEXTSTRING_ITER_INVALID), datum_str_(datum_str)
+    has_lob_header_(has_lob_header), state_(TEXTSTRING_ITER_INVALID), datum_str_(datum_str),
+    err_ret_(OB_SUCCESS)
   {
     if (is_lob_storage(type)) {
       validate_has_lob_header(has_lob_header_);
@@ -125,7 +126,7 @@ public:
   ObTextStringIter(const ObObj &obj) :
     type_(obj.get_type()), cs_type_(obj.get_collation_type()), is_init_(false), is_lob_(false),
     is_outrow_(false), has_lob_header_(obj.has_lob_header()), state_(TEXTSTRING_ITER_INVALID),
-    datum_str_(obj.get_string())
+    datum_str_(obj.get_string()), err_ret_(OB_SUCCESS)
   {
     if (is_lob_storage(obj.get_type())) {
       validate_has_lob_header(has_lob_header_);
@@ -134,7 +135,7 @@ public:
   ~ObTextStringIter();
 
   TO_STRING_KV(K_(type), K_(cs_type), K_(is_init), K_(is_lob), K_(is_outrow),
-    K_(state), K(datum_str_), KP_(ctx));
+    K_(state), K(datum_str_), KP_(ctx), K_(err_ret));
 
   int init(uint32_t buffer_len,
            const sql::ObBasicSessionInfo *session = NULL,
@@ -165,7 +166,7 @@ public:
   uint32_t get_last_accessed_byte_len();
   uint32_t get_accessed_len();
   uint32_t get_accessed_byte_len();
-
+  int get_inner_ret() { return err_ret_; }
   bool is_outrow_lob() { return is_outrow_; };
   int get_byte_len(int64_t &byte_len);
   int get_char_len(int64_t &char_length);
@@ -205,6 +206,7 @@ private:
   ObTextStringIterState state_;
   const ObString datum_str_;
   ObLobTextIterCtx *ctx_;
+  int err_ret_;
 };
 
 // wrapper class to handle templob output(including string types)

src/sql/engine/expr/ob_expr_concat.cpp

@@ -123,8 +123,9 @@ int ObExprConcat::calc_text(common::ObObj &result,
       }
       if (OB_FAIL(ret)) {
       } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        ret = OB_INVALID_DATA;
+        ret = (str_iter1.get_inner_ret() != OB_SUCCESS) ?
-        LOG_WARN("iter state invalid", K(ret), K(state));
+              str_iter1.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(str_iter1));
       }
       while (OB_SUCC(ret)
              && (state = str_iter2.get_next_block(src_block_data)) == TEXTSTRING_ITER_NEXT) {
@@ -134,8 +135,9 @@ int ObExprConcat::calc_text(common::ObObj &result,
       }
       if (OB_FAIL(ret)) {
       } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        ret = OB_INVALID_DATA;
+        ret = (str_iter2.get_inner_ret() != OB_SUCCESS) ?
-        LOG_WARN("iter state invalid", K(ret), K(state));
+              str_iter2.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(str_iter2));
       }
     }
     if (OB_SUCC(ret)) {
@@ -384,8 +386,9 @@ static int eval_concat_text(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &expr_da
         }
         if (OB_FAIL(ret)) {
         } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-          ret = OB_INVALID_DATA;
+          ret = (input_iter.get_inner_ret() != OB_SUCCESS) ?
-          LOG_WARN("iter state invalid", K(ret), K(state));
+                input_iter.get_inner_ret() : OB_INVALID_DATA;
+          LOG_WARN("iter state invalid", K(ret), K(state), K(input_iter));
         }
       }
     }

src/sql/engine/expr/ob_expr_instr.cpp

@@ -186,8 +186,9 @@ static int calc_oracle_instr_text(ObTextStringIter &haystack_iter,
         not_first_search = true;
       }
       if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        ret = OB_INVALID_DATA;
+        ret = (haystack_iter.get_inner_ret() != OB_SUCCESS) ?
-        LOG_WARN("get_calc_cs_type failed", K(ret), K(state));
+              haystack_iter.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(haystack_iter));
       } else {
         if (idx != 0) {
           // 需要加上get next block实际访问过的长度
@@ -238,7 +239,7 @@ static int calc_oracle_instr_text(ObTextStringIter &haystack_iter,
             haystack_data.assign_ptr(haystack_data.ptr(), accessed_byte_len);
           }
         }
-        for (; count < occ_int; ++count) {
+        for (; count < occ_int && OB_SUCC(ret); ++count) {
           if (OB_FAIL(ObExprOracleInstr::slow_reverse_search(calc_alloc, calc_cs_type, haystack_data,
                                                              needle_data, pos_int, 1, idx))) {
             LOG_WARN("slow_reverse_search failed", K(ret), K(calc_cs_type),
@@ -258,8 +259,9 @@ static int calc_oracle_instr_text(ObTextStringIter &haystack_iter,
       }
       if (OB_FAIL(ret)) {
       } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        ret = OB_INVALID_DATA;
+        ret = (haystack_iter.get_inner_ret() != OB_SUCCESS) ?
-        LOG_WARN("get_calc_cs_type failed", K(ret), K(state));
+              haystack_iter.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(haystack_iter));
       } else {
         if (idx != 0 && !access_inrow_lob_prefix) {
           // need to count accessed length by get_next_block

src/sql/engine/expr/ob_expr_instrb.cpp

@@ -122,12 +122,13 @@ static int calc_instrb_text(ObTextStringIter &haystack_iter,
     bool not_first_search = false;
     if (pos_int > 0) {
       int64_t count = 0;
-      while (count < occ_int && (state = haystack_iter.get_next_block(haystack_data)) == TEXTSTRING_ITER_NEXT) {
+      while (OB_SUCC(ret) && count < occ_int &&
+             (state = haystack_iter.get_next_block(haystack_data)) == TEXTSTRING_ITER_NEXT) {
         if (not_first_search) {
           ret_idx = -1;
           pos_int = 1;
         }
-        for (; count < occ_int; ++count) {
+        for (; count < occ_int && OB_SUCC(ret); ++count) {
           if (OB_FAIL(kmp_ctx->instrb_search(haystack_data, pos_int, 1, ret_idx))) {
             LOG_WARN("search needle in haystack failed", K(ret), K(haystack_data), K(needle_data));
           } else {
@@ -140,9 +141,11 @@ static int calc_instrb_text(ObTextStringIter &haystack_iter,
         }
         not_first_search = true;
       }
-      if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
+      if (OB_FAIL(ret)) {
-        ret = OB_INVALID_DATA;
+      } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        LOG_WARN("get_calc_cs_type failed", K(ret), K(state));
+        ret = (haystack_iter.get_inner_ret() != OB_SUCCESS) ?
+              haystack_iter.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(haystack_iter));
       } else {
         if (ret_idx != 0) { // add accessed length by get_next_block()
           ret_idx += haystack_iter.get_last_accessed_byte_len() + haystack_iter.get_start_offset();
@@ -172,7 +175,7 @@ static int calc_instrb_text(ObTextStringIter &haystack_iter,
           ret_idx = -1;
           pos_int = -1;
         }
-        for (; count < occ_int; ++count) {
+        for (; count < occ_int && OB_SUCC(ret); ++count) {
           if (OB_FAIL(kmp_ctx->instrb_search(haystack_data, pos_int, 1, ret_idx))) {
             LOG_WARN("search needle in haystack failed", K(ret), K(haystack_data), K(needle_data));
           } else {
@@ -187,8 +190,9 @@ static int calc_instrb_text(ObTextStringIter &haystack_iter,
       }
       if (OB_FAIL(ret)) {
       } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        ret = OB_INVALID_DATA;
+        ret = (haystack_iter.get_inner_ret() != OB_SUCCESS) ?
-        LOG_WARN("get_calc_cs_type failed", K(ret), K(state));
+              haystack_iter.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(haystack_iter));
       } else {
         if (ret_idx != 0) { // add accessed length by get_next_block()
           ret_idx += (max_access_byte_len - static_cast<int64_t>(haystack_iter.get_accessed_byte_len()));

src/sql/engine/expr/ob_expr_lower.cpp

@@ -437,8 +437,9 @@ int ObExprLowerUpper::calc_common(const ObExpr &expr, ObEvalCtx &ctx,
         }
         if (OB_FAIL(ret)) {
         } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-          ret = OB_INVALID_DATA;
+          ret = (src_iter.get_inner_ret() != OB_SUCCESS) ?
-          LOG_WARN("get_calc_cs_type failed", K(ret), K(state));
+                src_iter.get_inner_ret() : OB_INVALID_DATA;
+          LOG_WARN("iter state invalid", K(ret), K(state), K(src_iter));
         } else {
           output_result.get_result_buffer(str_result);
         }

src/sql/engine/expr/ob_expr_operator.cpp

@@ -5355,8 +5355,9 @@ int ObLocationExprOperator::calc_(const ObExpr &expr, const ObExpr &sub_arg,
                                   sub_str_data.ptr(), sub_str_data.length(), pos_int);
         }
         if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-          ret = OB_INVALID_DATA;
+          ret = (ori_str_iter.get_inner_ret() != OB_SUCCESS) ?
-          LOG_WARN("get_calc_cs_type failed", K(ret), K(state));
+                ori_str_iter.get_inner_ret() : OB_INVALID_DATA;
+          LOG_WARN("iter state invalid", K(ret), K(state), K(ori_str_iter));
         } else {
           if (idx != 0) {
             // need to add length accessed by get_next_block

src/sql/engine/expr/ob_expr_reverse.cpp

@@ -138,8 +138,9 @@ int calc_reverse_expr(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res_datum)
         }
         if (OB_FAIL(ret)) {
         } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-          ret = OB_INVALID_DATA;
+          ret = (input_iter.get_inner_ret() != OB_SUCCESS) ?
-          LOG_WARN("iter state invalid", K(ret), K(state));
+                input_iter.get_inner_ret() : OB_INVALID_DATA;
+          LOG_WARN("iter state invalid", K(ret), K(state), K(input_iter));
         } else {
           output_result.set_result();
         }

src/sql/engine/expr/ob_expr_substr.cpp

@@ -586,8 +586,9 @@ static int eval_substr_text(const ObCollationType &cs_type,
       }
       if (OB_FAIL(ret)) {
       } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-        ret = OB_INVALID_DATA;
+        ret = (input_iter.get_inner_ret() != OB_SUCCESS) ?
-        LOG_WARN("iter state invalid", K(ret), K(state));
+                input_iter.get_inner_ret() : OB_INVALID_DATA;
+        LOG_WARN("iter state invalid", K(ret), K(state), K(input_iter));
       } else {
         output_result.set_result();
       }

src/sql/engine/expr/ob_expr_substrb.cpp

@@ -485,8 +485,9 @@ int ObExprSubstrb::calc_substrb_expr(const ObExpr &expr, ObEvalCtx &ctx, ObDatum
         }
         if (OB_FAIL(ret)) {
         } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-          ret = OB_INVALID_DATA;
+          ret = (input_iter.get_inner_ret() != OB_SUCCESS) ?
-          LOG_WARN("iter state invalid", K(ret), K(state));
+                input_iter.get_inner_ret() : OB_INVALID_DATA;
+          LOG_WARN("iter state invalid", K(ret), K(state), K(input_iter));
         } else {
           output_result.set_result();
         }

src/sql/engine/expr/ob_expr_to_blob.cpp

@@ -114,8 +114,9 @@ int ObExprToBlob::eval_to_blob(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res)
           }
           if (OB_FAIL(ret)) {
           } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-            ret = OB_INVALID_DATA;
+            ret = (input_iter.get_inner_ret() != OB_SUCCESS) ?
-            LOG_WARN("iter state invalid", K(ret), K(state));
+                  input_iter.get_inner_ret() : OB_INVALID_DATA;
+            LOG_WARN("iter state invalid", K(ret), K(state), K(input_iter));
           } else {
             str_result.set_result();
             OB_ASSERT(off == res_len);

src/sql/engine/expr/ob_expr_trim.cpp

@@ -483,8 +483,9 @@ static int text_trim2(ObTextStringIter &str_iter,
     }
     if (OB_FAIL(ret)) {
     } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-      ret = OB_INVALID_DATA;
+      ret = (str_iter.get_inner_ret() != OB_SUCCESS) ?
-      LOG_WARN("iter state invalid", K(ret), K(state));
+            str_iter.get_inner_ret() : OB_INVALID_DATA;
+      LOG_WARN("iter state invalid", K(ret), K(state), K(str_iter));
     } else if (!output_result.is_init() && OB_FAIL(output_result.init(0))) { // nothing found build empty lob
       LOG_WARN("init stringtext result for empty lob failed", K(ret));
     } else {
@@ -650,8 +651,9 @@ static int text_trim(ObTextStringIter &str_iter,
     }
     if (OB_FAIL(ret)) {
     } else if (state != TEXTSTRING_ITER_NEXT && state != TEXTSTRING_ITER_END) {
-      ret = OB_INVALID_DATA;
+      ret = (str_iter.get_inner_ret() != OB_SUCCESS) ?
-      LOG_WARN("iter state invalid", K(ret), K(state));
+            str_iter.get_inner_ret() : OB_INVALID_DATA;
+      LOG_WARN("iter state invalid", K(ret), K(state), K(str_iter));
     } else if (!output_result.is_init() && OB_FAIL(output_result.init(0))) { // nothing found build empty lob
       LOG_WARN("init stringtext result for empty lob failed", K(ret));
     } else {