Fix to enable index scan with LIKE operator for non-const nodes

contrib/babelfishpg_tsql/src/collation.c

@@ -8,16 +8,20 @@
 #include "utils/syscache.h"
 #include "utils/memutils.h"
 #include "utils/builtins.h"
+#include "catalog/pg_proc.h"
 #include "catalog/pg_type.h"
 #include "catalog/pg_collation.h"
 #include "catalog/namespace.h"
 #include "tsearch/ts_locale.h"
+#include "optimizer/clauses.h"
+#include "optimizer/optimizer.h"
 #include "parser/parser.h"
 #include "parser/parse_coerce.h"
 #include "parser/parse_type.h"
 #include "parser/parse_oper.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodes.h"
+#include "nodes/pathnodes.h"
 #ifdef USE_ICU
 #include <unicode/utrans.h>
 #include "utils/removeaccent.map"
@@ -76,6 +80,87 @@ extern int	pattern_fixed_prefix_wrapper(Const *patt,
 static Node *transform_likenode_for_AI(OpExpr *op);
 static Node *convert_node_to_funcexpr_for_like(Node *node, Oid inputcollid);
 
+/*
+ * Check whether a like_escape call appears anywhere in the expression.
+ * Uses expression_tree_walker for safe traversal of all node types.
+ */
+static bool
+contains_like_escape(Node *node, void *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, FuncExpr) &&
+		strcmp(get_func_name(((FuncExpr *) node)->funcid),
+			   "like_escape") == 0)
+		return true;
+	return expression_tree_walker(node, contains_like_escape, context);
+}
+
+/*
+ * Check whether the expression contains any non-immutable function
+ * outside our allowlist of safe-to-fold stable functions.
+ * Returns true if an unsafe function is found.
+ *
+ * Allowlisted functions are STABLE only because plpgsql/C cannot be
+ * declared IMMUTABLE, but are deterministic for constant inputs:
+ *   babelfish_conv_helper_*   - CONVERT / TRY_CONVERT
+ *   babelfish_try_cast_to_*   - TRY_CAST
+ *   babelfish_concat_wrapper* - string + operator
+ *   concat                     - CONCAT()
+ */
+static bool
+has_unsafe_stable_func(Node *node, void *context)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, FuncExpr))
+	{
+		FuncExpr   *func = (FuncExpr *) node;
+
+		if (func_volatile(func->funcid) != PROVOLATILE_IMMUTABLE)
+		{
+			char   *name = get_func_name(func->funcid);
+			bool	safe = (name != NULL &&
+							(strncmp(name, "babelfish_conv_helper_", 22) == 0 ||
+							 strncmp(name, "babelfish_try_cast_to_", 22) == 0 ||
+							 strncmp(name, "babelfish_concat_wrapper", 24) == 0 ||
+							 strcmp(name, "concat") == 0));
+
+			if (name)
+				pfree(name);
+			if (!safe)
+				return true;
+		}
+	}
+	return expression_tree_walker(node, has_unsafe_stable_func, context);
+}
+
+/*
+ * Fold a LIKE pattern to Const, restricted to expressions whose
+ * non-immutable functions are all known-safe stable functions.
+ * The original LIKE is always kept as a recheck, so correctness
+ * is guaranteed.
+ */
+static Node *
+fold_like_pattern_to_const(Node *expr)
+{
+	PlannerGlobal glob;
+	PlannerInfo root;
+
+	if (has_unsafe_stable_func(expr, NULL))
+		return expr;
+
+	memset(&glob, 0, sizeof(PlannerGlobal));
+	glob.type = T_PlannerGlobal;
+	glob.boundParams = NULL;
+
+	memset(&root, 0, sizeof(PlannerInfo));
+	root.type = T_PlannerInfo;
+	root.glob = &glob;
+
+	return estimate_expression_value(&root, expr);
+}
+
 /* pattern prefix status for pattern_fixed_prefix_wrapper
  * Pattern_Prefix_None: no prefix found, this means the first character is a wildcard character
  * Pattern_Prefix_Exact: the pattern doesn't include any wildcard character
@@ -327,8 +412,9 @@ create_collate_expr(Node *arg, Oid collid)
  * function to remove the accents and optimize.
  * If the node is OpExpr and the collation is cs_as, then simply use optimization:
  *
- * Case 1: if the pattern is a constant stirng
- *		 col LIKE PATTERN -> col = PATTERN
+ * Case 1: if the pattern is a constant string
+ *		 col LIKE PATTERN -> col = PATTERN AND col LIKE PATTERN
+ *       col NOT LIKE PATTERN -> col <> PATTERN OR col NOT LIKE PATTERN
  * Case 2: if the pattern have a constant prefix
  *		 col LIKE PATTERN ->
  *		 col LIKE PATTERN BETWEEN prefix AND prefix||E'\uFFFF'
@@ -386,9 +472,8 @@ optimise_likenode(Node *node, OpExpr *op, like_ilike_info_t like_entry, coll_inf
 		op->opno = like_entry.ilike_oid;
 		op->opfuncid = like_entry.ilike_opfuncid;
 	}
-
-	op->inputcollid = tsql_get_oid_from_collidx(collidx_of_cs_as);
 
+	op->inputcollid = tsql_get_oid_from_collidx(collidx_of_cs_as);
 
 	/* Remove CollateExpr as the op->inputcollid has already been set */
 	if (IsA(rightop, CollateExpr))
@@ -401,6 +486,27 @@ optimise_likenode(Node *node, OpExpr *op, like_ilike_info_t like_entry, coll_inf
 		linitial(op->args) = leftop = (Node*)((CollateExpr*) leftop)->arg;
 	}
 
+	/*
+	 * Try to reduce rightop to a Const for prefix extraction.
+	 *
+	 * First use eval_const_expressions (folds immutable functions like
+	 * string concatenation and type casts). If still not a Const, use
+	 * fold_like_pattern_to_const which selectively folds only
+	 * allowlisted stable functions (CONVERT, TRY_CONVERT, TRY_CAST,
+	 * string +) via estimate_expression_value.
+	 *
+	 * Skip for like_escape: PG's like_escape converts escape sequences
+	 * to backslash format, which doesn't match T-SQL bracket patterns.
+	 * Folding it produces wrong prefix bounds.
+	 */
+	if (!contains_like_escape(rightop, NULL))
+	{
+		rightop = eval_const_expressions(NULL, rightop);
+		if (!IsA(rightop, Const))
+			rightop = fold_like_pattern_to_const(rightop);
+		lsecond(op->args) = rightop;
+	}
+
 	/* 
 	 * This is needed to process CI_AI for Const nodes
 	 * Because after we call coerce_to_target_type for type conversion in transform_likenode_for_AI,
@@ -466,8 +572,10 @@ optimise_likenode(Node *node, OpExpr *op, like_ilike_info_t like_entry, coll_inf
 	{
 		RelabelType	*relabel = (RelabelType *) leftop;
 		leftop = copyObject((Node*) relabel->arg);
-		prefix->consttype = rtypeId = ltypeId = exprType(leftop);
+		ltypeId = exprType(leftop);
 	}
+	/* Reconcile types — LIKE coerces to TEXT but we need original column type */
+	prefix->consttype = rtypeId = ltypeId;
 
 	/* 
 	 * We need to do this because the dump considers rightop as Const with COLLATE being added
@@ -506,7 +614,7 @@ optimise_likenode(Node *node, OpExpr *op, like_ilike_info_t like_entry, coll_inf
 									InvalidOid,
 									coll_info_of_inputcollid.oid,
 									oprfuncid(optup)));
-		ret = make_and_qual(ret, node);
+		ret = like_entry.is_not_match ? make_or_qual(ret, node) : make_and_qual(ret, node);
 		ReleaseSysCache(optup);
 	}
 	else
@@ -1053,6 +1161,42 @@ transform_likenode(Node *node, bool is_constraint)
 
 		get_remove_accents_internal_oid();
 
+		/*
+		 * View definitions (after dump/restore) lose original column collation 
+		 * due to ::text casts, causing wrong LIKE/ILIKE operator selection. 
+		 * Skip if an explicit COLLATE clause is present.
+		 */
+
+		if (OidIsValid(like_entry.like_oid) && list_length(op->args) >= 2)
+		{
+			Node *left_arg = linitial(op->args);
+			Node *right_arg = lsecond(op->args);
+			if (!IsA(left_arg, CollateExpr) && !IsA(right_arg, CollateExpr) && !contain_var_clause(right_arg))
+			{
+				Node *unwrapped = left_arg;
+				while (IsA(unwrapped, RelabelType))
+					unwrapped = (Node *) ((RelabelType *) unwrapped)->arg;
+
+				if (IsA(unwrapped, Var))
+				{
+					Oid var_collation = ((Var *) unwrapped)->varcollid;
+
+					if (OidIsValid(var_collation) &&
+						var_collation != op->inputcollid)
+					{
+						coll_info_t var_coll_info =
+							tsql_lookup_collation_table_internal(var_collation);
+
+						if (OidIsValid(var_coll_info.oid))
+						{
+							op->inputcollid = var_collation;
+							coll_info_of_inputcollid = var_coll_info;
+						}
+					}
+				}
+			}
+	    }
+
 		/*
 		 * We do not allow CREATE TABLE statements with CHECK constraint where
 		 * the constraint has an ILIKE operator and the collation is ci_as.

test/JDBC/expected/babel_collection.out

@@ -323,8 +323,8 @@ GO
 ~~START~~
 text
 Query Text: select c1 from testing4 where c1 NOT LIKE 'jones'
-Bitmap Heap Scan on testing4  (cost=11.56..31.31 rows=647 width=32)
-  Filter: ((c1 <> 'jones'::"varchar") AND ((c1)::text !~~* 'jones'::text COLLATE bbf_unicode_cp1_cs_as))
+Bitmap Heap Scan on testing4  (cost=11.56..31.31 rows=650 width=32)
+  Filter: ((c1 <> 'jones'::"varchar") OR ((c1)::text !~~* 'jones'::text COLLATE bbf_unicode_cp1_cs_as))
   ->  Bitmap Index Scan on c1_idxtesting49a168d73f3ba5aacdfd495b931b8d187  (cost=0.00..11.40 rows=650 width=0)
 ~~END~~
 

test/JDBC/expected/db_collation/babel_collection.out

@@ -311,8 +311,8 @@ GO
 ~~START~~
 text
 Query Text: select c1 from testing4 where c1 NOT LIKE 'jones'
-Bitmap Heap Scan on testing4  (cost=11.56..34.56 rows=647 width=32)
-  Filter: ((remove_accents_internal((c1)::text) <> 'jones'::nvarchar) AND ((remove_accents_internal((c1)::text))::text !~~* 'jones'::text COLLATE bbf_unicode_cp1_cs_as))
+Bitmap Heap Scan on testing4  (cost=11.56..34.56 rows=650 width=32)
+  Filter: ((remove_accents_internal((c1)::text) <> 'jones'::nvarchar) OR ((remove_accents_internal((c1)::text))::text !~~* 'jones'::text COLLATE bbf_unicode_cp1_cs_as))
   ->  Bitmap Index Scan on c1_idxtesting49a168d73f3ba5aacdfd495b931b8d187  (cost=0.00..11.40 rows=650 width=0)
 ~~END~~