[#26512] YSQL: Support MOD and some text expression pushdown in mixed mode

Summary:
Add support and tests for pushing down MOD, LIKE, ASCII, SUBSTRING when in mixed mode of a major
version upgrade.

Also, update the initiatial definition of `yb_mixed_mode_expression_pushdown` to `true` in `ybc_guc.cc` to match it's default in `guc.c`.

**Upgrade/Rollback safety**
This is safe without autoflags because tservers (both PG11 and PG15) already know how to handle each of these functions. Versions before this change will not push them down, versions with this change will push down these functions. However, in either case, whatever is sent to DocDB can be handled by default.
Jira: DB-15879

Test Plan:
```
./yb_build.sh --cxx-test integration-tests_ysql_major_upgrade_expression_pushdown-test
./yb_build.sh --cxx-test integration-tests_ysql_major_upgrade_expression_pushdown-test --gtest_filter YsqlMajorUpgradeExpressionPushdownTest.TestStringOperations
```

Output of the python collector script:
```
UNTESTED WHITELISTED FUNCTIONS 1 / 276
{2074: 'F_SUBSTRING_TEXT_TEXT_TEXT'}
```

`SUBSTRING_TEXT_TEXT_TEXT` is difficult to test, as it always gets rewritten to another
function. It is left whitelisted though.
```
explain analyze select * from tttt where (substring(t, 'h.'::text, c) = 'he'::text);
                                             QUERY PLAN
----------------------------------------------------------------------------------------------------
 Seq Scan on tttt  (cost=0.00..110.00 rows=1000 width=40) (actual time=3.630..3.631 rows=0 loops=1)
   Storage Filter: ("substring"(t, similar_to_escape('h.'::text, (c)::text)) = 'he'::text)
 Planning Time: 1.686 ms
 Execution Time: 3.754 ms
(4 rows)
```

Notice that `substring(t, 'h.'::text, c)` was rewritten to `"substring"(t, similar_to_escape('h.'::text, (c)::text))`

Reviewers: hsunder, amartsinchyk, fizaa

Reviewed By: fizaa

Subscribers: svc_phabricator, jason, yql

Differential Revision: https://phorge.dev.yugabyte.com/D42372

Author: timothy-e

src/postgres/src/backend/utils/misc/yb_exceptions_for_func_pushdown.c

@@ -195,6 +195,35 @@ const uint32 yb_funcs_safe_for_mixed_mode_pushdown[] = {
 	COMPARISON_OPS(TIMESTAMPTZ_),
 	COMPARISON_OPS(DATE_),
 	COMPARISON_OPS(INTERVAL_),
+
+	F_INT2MOD,
+	F_INT4MOD,
+	F_INT8MOD,
+	F_NUMERIC_MOD,
+	F_MOD_INT2_INT2,
+	F_MOD_INT4_INT4,
+	F_MOD_INT8_INT8,
+	F_MOD_NUMERIC_NUMERIC,
+
+	F_TEXTLIKE,
+	F_TEXTNLIKE,
+	F_LIKE_TEXT_TEXT,
+	F_NOTLIKE_TEXT_TEXT,
+	F_BPCHARLIKE,
+	F_BPCHARNLIKE,
+	F_TEXTICLIKE,
+	F_TEXTICNLIKE,
+	F_BPCHARICLIKE,
+	F_BPCHARICNLIKE,
+	F_TEXTREGEXEQ,
+	F_TEXTREGEXNE,
+
+	F_ASCII,
+
+	F_SUBSTRING_TEXT_TEXT,
+	F_SUBSTRING_TEXT_TEXT_TEXT,
+	F_SUBSTRING_TEXT_INT4,
+	F_SUBSTRING_TEXT_INT4_INT4,
 };
 
 #define DEFINE_ARRAY_SIZE(array) const int array##_count = lengthof(array)

src/yb/integration-tests/upgrade-tests/ysql_major_upgrade_expression_pushdown-test.cc

@@ -331,6 +331,46 @@ class YsqlMajorUpgradeExpressionPushdownTest : public YsqlMajorUpgradeTestBase {
       }
     }
 
+    const auto get_mod_name = [](std::string &col) {
+      if (col == kInt2Column) {
+        return "int2mod";
+      } else if (col == kInt4Column) {
+        return "int4mod";
+      } else if (col == kInt8Column) {
+        return "int8mod";
+      } else if (col == kNumericColumn) {
+        return "numeric_mod";
+      }
+      return "invalid mod function";
+    };
+
+    // Add MOD expressions
+    for (auto t1 : numeric_types) {
+      if (is_float(t1))
+        continue;
+      if (t1 == kInt4Column) {
+        for (const auto& mod_name : {get_mod_name(t1), "mod"}) {
+          exprs.push_back(Expression(Format("($0($1, 10) = 0)", mod_name, t1),
+                                    Behaviour::kPushable, Behaviour::kMMPushable));
+        }
+        exprs.push_back(Expression(Format("(($0 % 10) = 0)", t1),
+                                   Behaviour::kPushable, Behaviour::kMMPushable));
+      } else if (is_int(t1)) {
+        for (const auto& mod_name : {get_mod_name(t1), "mod"}) {
+          exprs.push_back(Expression(Format("($0($1, '10'::$2) = 0)", mod_name, t1, get_cast(t1)),
+                                     Behaviour::kPushable, Behaviour::kMMPushable));
+        }
+        exprs.push_back(Expression(Format("(($0 % '10'::$1) = 0)", t1, get_cast(t1)),
+                                   Behaviour::kPushable, Behaviour::kMMPushable));
+      } else {
+        for (const auto &mod_name : {"numeric_mod", "mod"}) {
+          exprs.push_back(Expression(Format("($0($1, '10'::numeric) = 0.0)", mod_name, t1),
+                                    Behaviour::kPushable, Behaviour::kMMPushable));
+        }
+        exprs.push_back(Expression(Format("(($0 % '10'::numeric) = 0.0)", t1),
+                                   Behaviour::kPushable, Behaviour::kMMPushable));
+      }
+    }
 
     exprs.push_back(Expression(Format("(($0)::integer = $1)", kBoolColumn, kInt4Column),
                                       Behaviour::kPushable, Behaviour::kMMPushable));
@@ -564,6 +604,66 @@ TEST_F(YsqlMajorUpgradeExpressionPushdownTest, TestNewPg15Functions) {
   }));
 }
 
+TEST_F(YsqlMajorUpgradeExpressionPushdownTest, TestStringOperations) {
+  static const auto kTable = "text_tbl";
+  static const auto kTextColumn = "text_col";
+  static const auto kVarcharColumn = "varchar_col";
+  static const auto kCharColumn = "char_col";
+  static const auto kBpCharColumn = "bpchar_col";
+
+  {
+    auto conn = ASSERT_RESULT(CreateConnToTs(kAnyTserver));
+    ASSERT_OK(conn.ExecuteFormat(
+        "CREATE TABLE $0($1 TEXT, $2 VARCHAR, $3 CHAR, $4 BPCHAR)",
+        kTable, kTextColumn, kVarcharColumn, kCharColumn, kBpCharColumn));
+    ASSERT_OK(conn.ExecuteFormat(
+        "INSERT INTO $0 VALUES ('hello', 'world', 'a', 'b')", kTable));
+  }
+
+  std::vector<Expression> exprs;
+  for (const auto &cond : {
+    Format("($0 ~~ 'h%'::text)", kTextColumn), // F_TEXTLIKE
+    Format("($0 !~~ 'h%'::text)", kTextColumn), // F_TEXTNLIKE
+    Format("($0 ~~ ($1)::text)", kTextColumn, kVarcharColumn), // F_LIKE_TEXT_TEXT
+    Format("($0 !~~ ($1)::text)", kTextColumn, kVarcharColumn), // F_NOTLIKE_TEXT_TEXT
+    Format("($0 ~~ 'b%'::text)", kBpCharColumn), // F_BPCHARLIKE
+    Format("($0 !~~ 'b%'::text)", kBpCharColumn), // F_BPCHARNLIKE
+    Format("($0 ~~* 'H%'::text)", kTextColumn), // F_TEXTICLIKE
+    Format("($0 !~~* 'H%'::text)", kTextColumn), // F_TEXTICNLIKE
+    Format("($0 ~~* 'B%'::text)", kBpCharColumn), // F_BPCHARICLIKE
+    Format("($0 !~~* 'B%'::text)", kBpCharColumn), // F_BPCHARICNLIKE
+    Format("($0 ~ 'h.*'::text)", kTextColumn), // F_TEXTREGEXEQ
+    Format("($0 !~ 'h.*'::text)", kTextColumn), // F_TEXTREGEXNE
+    Format("(ascii($0) = 104)", kTextColumn), // F_ASCII
+    Format("(\"substring\"($0, 'h.'::text) = 'he'::text)", kTextColumn), // F_SUBSTRING_TEXT_TEXT
+    Format("(\"substring\"($0, 2) = 'ello'::text)", kTextColumn), // F_SUBSTRING_TEXT_INT4
+    Format("(\"substring\"($0, 2, 3) = 'ell'::text)", kTextColumn), // F_SUBSTRING_TEXT_INT4_INT4
+  }) {
+    exprs.push_back(Expression(cond, Behaviour::kPushable, Behaviour::kMMPushable));
+  }
+
+  // special cases: the formatting for these conditions changes in the output depending on the YSQL
+  // version, so use a regex to check that the correct condition is present in the output
+  exprs.push_back(Expression(Format("like($0, 'h%'::text)", kTextColumn), // F_LIKE_TEXT_TEXT
+                             Behaviour::kPushable, Behaviour::kMMPushable, ".*like.*"));
+  exprs.push_back(Expression(Format("notlike($0, 'h%'::text)", kTextColumn), // F_NOTLIKE_TEXT_TEXT
+                             Behaviour::kPushable, Behaviour::kMMPushable, ".*notlike.*"));
+
+  // these functions don't exist in PG11, so they can't be pushed
+  exprs.push_back(Expression(Format("regexp_like($0, 'h.*'::text)", kTextColumn),
+                             Behaviour::kFunctionError, Behaviour::kPushable, ".*regexp_like.*"));
+
+  for (const auto& cond : {
+    Format("(regexp_substr($0, 'h.'::text) = 'he'::text)", kTextColumn),
+    Format("(regexp_substr($0, 'h.'::text, 1) = 'he'::text)", kTextColumn),
+  }) {
+    exprs.push_back(Expression(cond, Behaviour::kFunctionError, Behaviour::kPushable));
+  }
+
+  const auto prefix = Format("EXPLAIN $0 SELECT * FROM $1 WHERE", kExplainArgs, kTable);
+  ASSERT_OK(TestPushdowns(prefix, exprs));
+}
+
 TEST_F(YsqlMajorUpgradeExpressionPushdownTest, TestTimePushdowns) {
   static const auto kTimeTable = "time_tbl";
   static const auto kTimestampCol = "timestamp_col";

src/yb/yql/pggate/util/ybc_guc.cc

@@ -119,4 +119,4 @@ bool yb_disable_auto_analyze = false;
 
 bool yb_extension_upgrade = false;
 
-bool yb_mixed_mode_expression_pushdown = false;
+bool yb_mixed_mode_expression_pushdown = true;