[UT] No need to generate result in record mode for uncheck stmt (#72592)

Signed-off-by: trueeyu <lxhhust350@qq.com>
(cherry picked from commit ae82a38)

# Conflicts:
#	test/test_sql_cases.py

Author: trueeyu

test/lib/sr_sql_lib.py

@@ -1153,7 +1153,7 @@ def execute_thread(self, exec_id, cmd_list, res_list, ori_cmd_list, record_mode,
 
             old_this_res_len = len(this_res)
             actual_res, actual_res_log, var, order = self.execute_single_statement(
-                _each_cmd, _cmd_id_str, record_mode, this_res, var_key=exec_id, conn=conn
+                _each_cmd, _cmd_id_str, record_mode and not uncheck, this_res, var_key=exec_id, conn=conn
             )
 
             if record_mode:

test/test_sql_cases.py

@@ -439,7 +439,9 @@ def test_sql_basic(self, case_info: choose_cases.ChooseCase.CaseTR):
                     uncheck = True
                     sql = sql[len(sr_sql_lib.UNCHECK_FLAG) :]
 
-                actual_res, actual_res_log, var, order = self.execute_single_statement(sql, sql_id, record_mode)
+                actual_res, actual_res_log, var, order = self.execute_single_statement(
+                    sql, sql_id, record_mode and not uncheck
+                )
 
                 if not record_mode and not uncheck:
                     # check mode only work in validating mode
@@ -487,6 +489,114 @@ def test_sql_basic(self, case_info: choose_cases.ChooseCase.CaseTR):
                         self.res_log.append("} END CLEANUP")
                 # do nothing during execution here; cleanup executes in tearDown
                 continue
+<<<<<<< HEAD
+=======
+            elif isinstance(sql, dict) and sql.get("type", "") == SET_VAR_FLAG:
+                # SET_VAR block: run SQL statements with each session variable combination
+                combinations = sql["combinations"]
+                set_var_stats = sql["stat"]
+                set_var_results = sql.get("res", [])
+
+                self_print(
+                    f"\n[SET_VAR] Start: {len(combinations)} combination(s)...",
+                    color=ColorEnum.BLUE, logout=True, bold=True
+                )
+
+                if record_mode:
+                    # Record mode: execute with first combination and record results,
+                    # then verify remaining combinations produce the same outcome.
+                    self.res_log.append(SET_VAR_FLAG + " {")
+                    self.res_log.append("  PROPERTY: %s" % json.dumps(combinations))
+
+                    # --- first combination: execute & record ---
+                    first_combo = combinations[0]
+                    combo_desc = ", ".join(f"{k}={v}" for k, v in first_combo.items())
+                    self_print(
+                        f"[SET_VAR] Recording combination 1/{len(combinations)}: {combo_desc}",
+                        color=ColorEnum.BLUE, logout=True
+                    )
+                    for var_name, var_value in first_combo.items():
+                        self.execute_sql("SET %s = %s;" % (var_name, var_value))
+
+                    ori_set_var = case_info.ori_sql[sql_id]
+                    for stmt_id, stmt in enumerate(set_var_stats):
+                        # append original statement text (with ${uuid} placeholders) to R file
+                        if isinstance(ori_set_var, dict):
+                            self.res_log.append(ori_set_var["stat"][stmt_id])
+                        else:
+                            self.res_log.append(stmt)
+
+                        uncheck = False
+                        run_stmt = stmt
+                        if run_stmt.startswith(sr_sql_lib.UNCHECK_FLAG):
+                            uncheck = True
+                            run_stmt = run_stmt[len(sr_sql_lib.UNCHECK_FLAG):]
+
+                        actual_res, actual_res_log, var, order = self.execute_single_statement(
+                            run_stmt, sql_id, not uncheck
+                        )
+
+                    # --- remaining combinations: execute & verify against recorded results ---
+                    for combo_id, combo in enumerate(combinations[1:], 2):
+                        combo_desc = ", ".join(f"{k}={v}" for k, v in combo.items())
+                        self_print(
+                            f"[SET_VAR] Verifying combination {combo_id}/{len(combinations)}: {combo_desc}",
+                            color=ColorEnum.BLUE, logout=True
+                        )
+                        for var_name, var_value in combo.items():
+                            self.execute_sql("SET %s = %s;" % (var_name, var_value))
+
+                        for stmt_id, stmt in enumerate(set_var_stats):
+                            run_stmt = stmt
+                            uncheck = False
+                            if run_stmt.startswith(sr_sql_lib.UNCHECK_FLAG):
+                                uncheck = True
+                                run_stmt = run_stmt[len(sr_sql_lib.UNCHECK_FLAG):]
+                            self.execute_single_statement(run_stmt, sql_id, False)
+
+                    self.res_log.append("} " + END_SET_VAR_FLAG)
+
+                else:
+                    # Validation mode: run all combinations and check results
+                    for combo_id, combo in enumerate(combinations):
+                        combo_desc = ", ".join(f"{k}={v}" for k, v in combo.items())
+                        self_print(
+                            f"[SET_VAR] Combination {combo_id + 1}/{len(combinations)}: {combo_desc}",
+                            color=ColorEnum.BLUE, logout=True
+                        )
+
+                        # set session variables for this combination
+                        for var_name, var_value in combo.items():
+                            self.execute_sql("SET %s = %s;" % (var_name, var_value))
+
+                        # execute all statements and check results
+                        for stmt_id, stmt in enumerate(set_var_stats):
+                            uncheck = False
+                            ori_stmt = stmt
+
+                            if stmt.startswith(sr_sql_lib.UNCHECK_FLAG):
+                                uncheck = True
+                                stmt = stmt[len(sr_sql_lib.UNCHECK_FLAG):]
+
+                            actual_res, actual_res_log, var, order = self.execute_single_statement(
+                                stmt, sql_id, False
+                            )
+
+                            if not uncheck and stmt_id < len(set_var_results):
+                                expect_res = set_var_results[stmt_id]
+                                expect_res_for_log = expect_res if len(expect_res) < 1000 else expect_res[:1000] + "..."
+
+                                log.info(
+                                    f"[SET_VAR {combo_id + 1}/{len(combinations)} - {stmt_id}.result]: "
+                                    f"\n    - [exp]: {expect_res_for_log}"
+                                    f"\n    - [act]: {actual_res}"
+                                )
+
+                                self.check(sql_id, stmt, expect_res, actual_res, order, ori_stmt)
+
+                self_print(f"[SET_VAR] Finish!", color=ColorEnum.BLUE, logout=True, bold=True)
+
+>>>>>>> ae82a38dba ([UT] No need to generate result in record mode for uncheck stmt (#72592))
             elif isinstance(sql, dict) and sql["type"] == sr_sql_lib.CONCURRENCY_FLAG:
                 # concurrency statement
                 self_print(f"[CONCURRENCY] Start...", color=ColorEnum.CYAN, logout=True)