fix: fix the compatibility problem of dml operations when has row level triggers

src/sql/engine/dml/ob_table_delete_op.cpp

@@ -140,6 +140,9 @@ int ObTableDeleteOp::check_need_exec_single_row()
   for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.del_ctdefs_.count() && !execute_single_row_; ++i) {
     const ObTableDeleteSpec::DelCtDefArray &ctdefs = MY_SPEC.del_ctdefs_.at(i);
     const ObDelCtDef &del_ctdef = *ctdefs.at(0);
+    if (has_before_row_trigger(del_ctdef) || has_after_row_trigger(del_ctdef)) {
+      execute_single_row_ = true;
+    }
     const ObForeignKeyArgArray &fk_args = del_ctdef.fk_args_;
     for (int j = 0; OB_SUCC(ret) && j < fk_args.count() && !execute_single_row_; j++) {
       if (fk_args.at(j).is_self_ref_ && fk_args.at(j).ref_action_ == ACTION_CASCADE) {

src/sql/engine/dml/ob_table_insert_all_op.cpp

@@ -109,6 +109,9 @@ int ObTableInsertAllOp::check_need_exec_single_row()
     const ObInsCtDef &ins_ctdef = *(ctdefs.at(0));
     const uint64_t table_id = ins_ctdef.das_base_ctdef_.index_tid_;
     const ObForeignKeyArgArray &fk_args = ins_ctdef.fk_args_;
+    if (has_before_row_trigger(ins_ctdef) || has_after_row_trigger(ins_ctdef)) {
+      execute_single_row_ = true;
+    }
     for (int j = 0; OB_SUCC(ret) && j < fk_args.count() && !execute_single_row_; j++) {
       const ObForeignKeyArg &fk_arg = fk_args.at(j);
       const uint64_t parent_table_id = fk_arg.table_id_;

src/sql/engine/dml/ob_table_insert_op.cpp

@@ -108,6 +108,19 @@ OB_DEF_SERIALIZE_SIZE(ObTableInsertSpec)
   return len;
 }
 
+int ObTableInsertOp::check_need_exec_single_row()
+{
+  int ret = OB_SUCCESS;
+  for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.ins_ctdefs_.count() && !execute_single_row_; ++i) {
+    const ObTableInsertSpec::InsCtDefArray &ctdefs = MY_SPEC.ins_ctdefs_.at(i);
+    const ObInsCtDef &ins_ctdef = *ctdefs.at(0);
+    if (has_before_row_trigger(ins_ctdef) || has_after_row_trigger(ins_ctdef)) {
+      execute_single_row_ = true;
+    }
+  }
+  return ret;
+}
+
 OB_INLINE int ObTableInsertOp::inner_open_with_das()
 {
   int ret = OB_SUCCESS;

src/sql/engine/dml/ob_table_insert_op.h

@@ -92,6 +92,7 @@ protected:
 
   int check_insert_affected_row();
   virtual void record_err_for_load_data(int err_ret, int row_num) override;
+  virtual int check_need_exec_single_row() override;
 protected:
   InsRtDef2DArray ins_rtdefs_; //see the comment of InsCtDef2DArray
 private:

src/sql/engine/dml/ob_table_insert_up_op.cpp

@@ -88,6 +88,24 @@ OB_DEF_SERIALIZE_SIZE(ObTableInsertUpSpec)
   return len;
 }
 
+int ObTableInsertUpOp::check_need_exec_single_row()
+{
+  int ret = OB_SUCCESS;
+  ObInsertUpCtDef *insert_up_ctdef = MY_SPEC.insert_up_ctdefs_.at(0);
+  const ObInsCtDef *ins_ctdef = insert_up_ctdef->ins_ctdef_;
+  const ObUpdCtDef *upd_ctdef = insert_up_ctdef->upd_ctdef_;
+  if (OB_NOT_NULL(ins_ctdef) && OB_NOT_NULL(upd_ctdef)) {
+    if (has_before_row_trigger(*ins_ctdef) || has_after_row_trigger(*ins_ctdef) ||
+      has_before_row_trigger(*upd_ctdef) || has_after_row_trigger(*upd_ctdef)) {
+    execute_single_row_ = true;
+    }
+  } else {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("ins_ctdef or upd_ctdef of primary table is nullptr", K(ret));
+  }
+  return ret;
+}
+
 int ObTableInsertUpOp::inner_open()
 {
   int ret = OB_SUCCESS;

src/sql/engine/dml/ob_table_insert_up_op.h

@@ -207,6 +207,7 @@ protected:
   int init_insert_up_rtdef();
 
   int deal_hint_part_selection(ObObjectID partition_id);
+  virtual int check_need_exec_single_row() override;
 
 private:
   int check_insert_up_ctdefs_valid() const;

src/sql/engine/dml/ob_table_merge_op.cpp

@@ -153,6 +153,33 @@ ObTableMergeOp::ObTableMergeOp(ObExecContext &ctx, const ObOpSpec &spec, ObOpInp
 {
 }
 
+int ObTableMergeOp::check_need_exec_single_row()
+{
+  int ret = OB_SUCCESS;
+  ObMergeCtDef *merge_ctdef = MY_SPEC.merge_ctdefs_.at(0);
+  if (!execute_single_row_ && OB_NOT_NULL(merge_ctdef->ins_ctdef_)) {
+    const ObInsCtDef &ins_ctdef = *merge_ctdef->ins_ctdef_;
+    if (has_before_row_trigger(ins_ctdef) || has_after_row_trigger(ins_ctdef)) {
+      execute_single_row_ = true;
+    }
+  }
+
+  if (!execute_single_row_ && OB_NOT_NULL(merge_ctdef->upd_ctdef_)) {
+    const ObUpdCtDef &upd_ctdef = *merge_ctdef->upd_ctdef_;
+    if (has_before_row_trigger(upd_ctdef) || has_after_row_trigger(upd_ctdef)) {
+      execute_single_row_ = true;
+    }
+  }
+
+  if (!execute_single_row_ && OB_NOT_NULL(merge_ctdef->del_ctdef_)) {
+    const ObDelCtDef &del_ctdef = *merge_ctdef->del_ctdef_;
+    if (has_before_row_trigger(del_ctdef) || has_after_row_trigger(del_ctdef)) {
+      execute_single_row_ = true;
+    }
+  }
+  return ret;
+}
+
 int ObTableMergeOp::inner_open_with_das()
 {
   int ret = OB_SUCCESS;

src/sql/engine/dml/ob_table_merge_op.h

@@ -116,6 +116,7 @@ protected:
   int close_table_for_each();
   virtual int write_row_to_das_buffer() override;
   virtual int write_rows_post_proc(int last_errno) override;
+  virtual int check_need_exec_single_row() override;
 
 protected:
   int64_t affected_rows_;

src/sql/engine/dml/ob_table_replace_op.cpp

@@ -94,6 +94,23 @@ OB_DEF_SERIALIZE_SIZE(ObTableReplaceSpec)
   return len;
 }
 
+int ObTableReplaceOp::check_need_exec_single_row()
+{
+  int ret = OB_SUCCESS;
+  ObReplaceCtDef *replace_ctdef = MY_SPEC.replace_ctdefs_.at(0);
+  const ObInsCtDef *ins_ctdef = replace_ctdef->ins_ctdef_;
+  const ObDelCtDef *del_ctdef = replace_ctdef->del_ctdef_;
+  if (OB_NOT_NULL(ins_ctdef) || OB_NOT_NULL(del_ctdef)) {
+    if (has_before_row_trigger(*ins_ctdef) || has_after_row_trigger(*ins_ctdef)
+        || has_before_row_trigger(*del_ctdef) || has_after_row_trigger(*del_ctdef)) {
+      execute_single_row_ = true;
+    }
+  } else {
+    ret = OB_ERR_UNEXPECTED;
+    LOG_WARN("ins_ctdef or del_ctdef of primary table is nullptr", K(ret));
+  }
+  return ret;
+}
 
 int ObTableReplaceOp::inner_open()
 {

src/sql/engine/dml/ob_table_replace_op.h

@@ -133,6 +133,7 @@ protected:
   int check_values(bool &is_equal,
                    const ObChunkDatumStore::StoredRow *replace_row,
                    const ObChunkDatumStore::StoredRow *delete_row);
+  virtual int check_need_exec_single_row() override;
 private:
   int check_replace_ctdefs_valid() const;
 

src/sql/engine/dml/ob_table_update_op.cpp

@@ -113,6 +113,19 @@ ObTableUpdateOp::ObTableUpdateOp(ObExecContext &exec_ctx, const ObOpSpec &spec,
 {
 }
 
+int ObTableUpdateOp::check_need_exec_single_row()
+{
+  int ret = OB_SUCCESS;
+  for (int64_t i = 0; OB_SUCC(ret) && i < MY_SPEC.upd_ctdefs_.count() && !execute_single_row_; ++i) {
+    const ObTableUpdateSpec::UpdCtDefArray &ctdefs = MY_SPEC.upd_ctdefs_.at(i);
+    const ObUpdCtDef &upd_ctdef = *ctdefs.at(0);
+    if (has_before_row_trigger(upd_ctdef) || has_after_row_trigger(upd_ctdef)) {
+      execute_single_row_ = true;
+    }
+  }
+  return ret;
+}
+
 int ObTableUpdateOp::inner_open()
 {
   int ret = OB_SUCCESS;

src/sql/engine/dml/ob_table_update_op.h

@@ -108,6 +108,7 @@ protected:
   int check_update_affected_row();
   virtual int write_row_to_das_buffer() override;
   virtual int write_rows_post_proc(int last_errno) override;
+  virtual int check_need_exec_single_row() override;
 
 protected:
   UpdRtDef2DArray upd_rtdefs_;  //see the comment of UpdCtDef2DArray