Fix observer core when das scan op release.

src/sql/das/ob_das_group_scan_op.cpp

@@ -37,11 +37,6 @@ ObDASGroupScanOp::~ObDASGroupScanOp()
     //Memory of lookupop come from op_alloc,We do not need free,just set ptr to null.
     group_lookup_op_ = nullptr;
   }
-
-  if (result_iter_ != nullptr && result_iter_->get_type() == ObNewRowIterator::ObTableScanIterator) {
-    LOG_ERROR_RET(OB_ERR_UNEXPECTED, "table group scan iter is not released, maybe some bug occured",
-              KPC(scan_ctdef_), K(scan_param_), KPC(scan_rtdef_));
-  }
 }
 
 int ObDASGroupScanOp::rescan()
@@ -69,10 +64,21 @@ int ObDASGroupScanOp::rescan()
 int ObDASGroupScanOp::release_op()
 {
   int ret = OB_SUCCESS;
-  OZ(ObDASScanOp::release_op());
+  int group_ret = OB_SUCCESS;
+
+  if (OB_FAIL(ObDASScanOp::release_op())) {
+    LOG_WARN("release das scan op fail", K(ret));
+  }
+
   if (nullptr != group_lookup_op_) {
-    if (OB_FAIL(group_lookup_op_->revert_iter())) {
+    group_ret = group_lookup_op_->revert_iter();
-      LOG_WARN("revert lookup iterator failed", K(ret));
+    if (OB_SUCCESS != group_ret) {
+      LOG_WARN("revert lookup iterator failed", K(group_ret));
+    }
+    //Only cover ret code when DASScanOp release success.
+    //In current implement group lookup op revert always return OB_SUCCESS.
+    if (OB_SUCCESS == ret) {
+      ret = group_ret;
     }
   }
   group_lookup_op_ = NULL;
@@ -259,18 +265,6 @@ int ObDASGroupScanOp::decode_task_result(ObIDASTaskResult *task_result)
 }
 ObGroupLookupOp::~ObGroupLookupOp()
 {
-  const ObNewRowIterator *lookup_iter = get_lookup_storage_iter();
-  if (lookup_iter != nullptr && lookup_iter->get_type() == ObNewRowIterator::ObTableScanIterator) {
-    LOG_ERROR_RET(OB_ERR_UNEXPECTED, "lookup_iter iter is not released, maybe some bug occured",
-              KPC(lookup_ctdef_), K(scan_param_), KPC(index_ctdef_),
-              K(lookup_rowkey_cnt_), K(lookup_row_cnt_));
-  }
-  const ObNewRowIterator *rowkey_iter = static_cast<ObGroupScanIter *>(get_rowkey_iter())->get_iter();
-  if (rowkey_iter != nullptr && rowkey_iter->get_type() == ObNewRowIterator::ObTableScanIterator) {
-    LOG_ERROR_RET(OB_ERR_UNEXPECTED, "rowkey_iter iter is not released, maybe some bug occured",
-              KPC(lookup_ctdef_), K(scan_param_), KPC(index_ctdef_),
-              K(lookup_rowkey_cnt_), K(lookup_row_cnt_));
-  }
 }
 
 int ObGroupLookupOp::init_group_range(int64_t cur_group_idx, int64_t group_size)
@@ -371,11 +365,11 @@ int ObGroupLookupOp::set_lookup_scan_group(int64_t group_id)
 int ObGroupLookupOp::revert_iter()
 {
   int ret = OB_SUCCESS;
-  if (OB_FAIL(ObLocalIndexLookupOp::revert_iter())) {
+  /*
-    LOG_WARN("revert ObLocalIndexLookupOp fail",K(ret));
+   * ObLookupOp will call ObLocalIndexLookupOp::revert_iter();
-  } else {
+   * We do not need revert twice!
-    group_iter_.reset();
+  */
-  }
+  group_iter_.reset();
   return ret;
 }
 

src/sql/das/ob_das_scan_op.cpp

@@ -171,13 +171,6 @@ ObDASScanOp::ObDASScanOp(ObIAllocator &op_alloc)
 
 ObDASScanOp::~ObDASScanOp()
 {
-  if (result_ != nullptr && result_->get_type() == ObNewRowIterator::ObTableScanIterator) {
-    LOG_ERROR_RET(OB_ERR_UNEXPECTED, "table scan iter is not released, maybe some bug occured",
-              KPC(scan_ctdef_), K(scan_param_), KPC(scan_rtdef_));
-    #ifdef ENABLE_SANITY
-    abort();
-    #endif
-  }
   scan_param_.destroy();
   trans_info_array_.destroy();
 }
@@ -321,24 +314,36 @@ int ObDASScanOp::open_op()
 int ObDASScanOp::release_op()
 {
   int ret = OB_SUCCESS;
+  int lookup_ret = OB_SUCCESS;
   ObITabletScan &tsc_service = get_tsc_service();
   if (result_ != nullptr) {
     if (ObNewRowIterator::IterType::ObLocalIndexLookupIterator == result_->get_type() ||
         ObNewRowIterator::IterType::ObGroupLookupOp == result_->get_type()) {
       ObLocalIndexLookupOp *lookup_op = static_cast<ObLocalIndexLookupOp*>(result_);
-      if (OB_FAIL(tsc_service.revert_scan_iter(lookup_op->get_rowkey_iter()))) {
+
+      ret = tsc_service.revert_scan_iter(lookup_op->get_rowkey_iter());
+      if (OB_SUCCESS != ret) {
         LOG_WARN("revert scan iterator failed", K(ret));
-      } else if (OB_FAIL(lookup_op->revert_iter())) {
+      }
-        LOG_WARN("revert lookup iterator failed", K(ret));
+
-      } else {
+      lookup_ret = lookup_op->revert_iter();
-        result_ = nullptr;
+      if (OB_SUCCESS != lookup_ret) {
+        LOG_WARN("revert lookup iterator failed", K(lookup_ret));
+      }
+
+      result_ = nullptr;
+      //if row_key revert is succ return look_up iter ret code.
+      //if row_key revert is fail return row_key iter ret code.
+      //In short if row_key and look_up iter all revert fail.
+      //We just ignore lookup_iter ret code.
+      if (OB_SUCCESS == ret) {
+        ret = lookup_ret;
       }
     } else {
       if (OB_FAIL(tsc_service.revert_scan_iter(result_))) {
         LOG_WARN("revert scan iterator failed", K(ret));
-      } else {
-        result_ = nullptr;
       }
+      result_ = nullptr;
     }
   }
   //need to clear the flag:need_switch_param_
@@ -802,17 +807,7 @@ OB_SERIALIZE_MEMBER((ObDASScanResult, ObIDASTaskResult),
 
 ObLocalIndexLookupOp::~ObLocalIndexLookupOp()
 {
-  if (lookup_iter_ != nullptr && lookup_iter_->get_type() == ObNewRowIterator::ObTableScanIterator) {
-    LOG_ERROR_RET(OB_ERR_UNEXPECTED, "lookup_iter_ iter is not released, maybe some bug occured",
-              KPC(lookup_ctdef_), K(scan_param_), KPC(index_ctdef_),
-              K(lookup_rowkey_cnt_), K(lookup_row_cnt_));
-  }
 
-  if (rowkey_iter_ != nullptr && rowkey_iter_->get_type() == ObNewRowIterator::ObTableScanIterator) {
-    LOG_ERROR_RET(OB_ERR_UNEXPECTED, "rowkey_iter_ iter is not released, maybe some bug occured",
-              KPC(lookup_ctdef_), K(scan_param_), KPC(index_ctdef_),
-              K(lookup_rowkey_cnt_), K(lookup_row_cnt_));
-  }
 }
 
 int ObLocalIndexLookupOp::init(const ObDASScanCtDef *lookup_ctdef,