MB-72184: add UDF drop regression test (bug fixed)

Add regression test
test_system_functions_after_drop_no_key_not_found to verify dropped functions are not returned
in system:functions and no key-not-found behavior occurs. Also include the test
in py-tuq-udf.conf.

Change-Id: Iaf1d57e88639a8cca8671afe8380ba035709f356
Reviewed-on: https://review.couchbase.org/c/testrunner/+/247171
Reviewed-by: <pavan.pb@couchbase.com>
Tested-by: <veena.k@couchbase.com>

Author: veenak-tester

conf/tuq/py-early-filter.conf

@@ -32,3 +32,4 @@ tuqquery.tuq_early_filter_order.QueryEarlyFilterTests:
     test_covering_in_early_filter
     test_MB63069
     test_MB_66614
+    test_early_filter_applied_on_indexscan_for_join_predicates

conf/tuq/py-tuq-ext-sanity.conf

@@ -17,6 +17,7 @@ tuqquery.tuq_sanity.QuerySanityTests:
     test_where_millis,GROUP=DATE;P0;CE
     test_order_by_dates,GROUP=DATE;P0;CE
     test_MB63998,GROUP=P0
+    test_MB70834_union_scan_for_or_predicate_with_partial_indexes,GROUP=P0
     test_slice_filter,GROUP=P0
 tuqquery.tuq_update_statistics.QueryUpdateStatsTests:
     test_update_stats_index_multi,bucket_size=300,bucket_name=travel-sample,load_sample=True,GROUP=NON_CE

conf/tuq/py-tuq-udf.conf

@@ -14,6 +14,7 @@ tuqquery.tuq_UDF.QueryUDFTests:
     test_inline_create_or_replace,GROUP=P1
     test_system_functions_create_and_replace,GROUP=P1
     test_system_functions_drop,GROUP=P1
+    test_system_functions_after_drop_no_key_not_found,GROUP=P1
     test_inline_query_function,GROUP=P1
     test_inline_query_function_no_index,GROUP=P1
     test_inline_query_function_syntax_error,GROUP=P1

pytests/tuqquery/tuq_UDF.py

@@ -628,6 +628,43 @@ def test_system_functions_drop(self):
             self.log.error(str(e))
             self.fail()
 
+    def test_system_functions_after_drop_no_key_not_found(self):
+        """MB-72184: Verify dropped UDFs are not returned in system:functions and
+        do not cause key-not-found errors after deletion."""
+        function_names = [
+            "func_global_mb72184",
+            "func_scope_a_mb72184",
+            "func_scope_b_mb72184",
+        ]
+        try:
+            self.run_cbq_query("CREATE FUNCTION `default`:`{0}`() {{ 0 }}".format(function_names[0]))
+            self.run_cbq_query("CREATE FUNCTION `default`:`default`.`_default`.`{0}`() {{ 0 }}".format(function_names[1]))
+            self.run_cbq_query("CREATE FUNCTION `default`:`default`.`_default`.`{0}`() {{ 0 }}".format(function_names[2]))
+
+            self.run_cbq_query("DROP FUNCTION `default`:`{0}`".format(function_names[0]))
+            self.run_cbq_query("DROP FUNCTION `default`:`default`.`_default`.`{0}`".format(function_names[1]))
+            self.run_cbq_query("DROP FUNCTION `default`:`default`.`_default`.`{0}`".format(function_names[2]))
+
+            for _ in range(5):
+                result = self.run_cbq_query("SELECT f.identity.name FROM system:functions AS f ORDER BY f.identity.name")
+                returned_names = [row.get("name") for row in result.get("results", []) if isinstance(row, dict)]
+                for fn in function_names:
+                    self.assertTrue(fn not in returned_names, "{0} still present in system:functions".format(fn))
+        except Exception as e:
+            self.log.error(str(e))
+            self.fail()
+        finally:
+            drop_queries = [
+                "DROP FUNCTION `default`:`{0}` IF EXISTS".format(function_names[0]),
+                "DROP FUNCTION `default`:`default`.`_default`.`{0}` IF EXISTS".format(function_names[1]),
+                "DROP FUNCTION `default`:`default`.`_default`.`{0}` IF EXISTS".format(function_names[2]),
+            ]
+            for query in drop_queries:
+                try:
+                    self.run_cbq_query(query)
+                except Exception as e:
+                    self.log.error(str(e))
+
     def test_inline_query_function(self):
         try:
             self.run_cbq_query("CREATE OR REPLACE FUNCTION func1(nameval) {{ (select * from default:default.{0}.{1} where name = nameval) }}".format(self.scope,self.collections[0]))

pytests/tuqquery/tuq_early_filter_order.py

@@ -1003,3 +1003,75 @@ def test_MB64917(self):
         self.assertEqual(result['results'], expected)
         self.assertTrue('index_keys' not in str(plan), "We expect early filter order not to occur please check plan: {plan}")
         self.assertTrue(operator1 == 'IndexScan3' and operator2 != 'Order')
+
+    def test_early_filter_applied_on_indexscan_for_join_predicates(self):
+        """MB-70928: Verify early filter is applied on index scan for join predicates."""
+        idx1 = "idx_mb70928_ix1"
+        idx3 = "idx_mb70928_ix3"
+        doc_m = "mb70928_m"
+        doc_cfl = "mb70928_cfl"
+
+        def _find_m_index_scan(plan_node):
+            if isinstance(plan_node, dict):
+                if (plan_node.get("#operator") == "IndexScan3" and
+                        plan_node.get("as") == "m" and
+                        plan_node.get("index") == idx1):
+                    return plan_node
+                for key in ("~children", "scans"):
+                    child_nodes = plan_node.get(key, [])
+                    if isinstance(child_nodes, list):
+                        for child in child_nodes:
+                            found = _find_m_index_scan(child)
+                            if found:
+                                return found
+                if "~child" in plan_node:
+                    found = _find_m_index_scan(plan_node["~child"])
+                    if found:
+                        return found
+            elif isinstance(plan_node, list):
+                for child in plan_node:
+                    found = _find_m_index_scan(child)
+                    if found:
+                        return found
+            return None
+
+        try:
+            self.run_cbq_query(
+                "UPSERT INTO default VALUES "
+                "('{0}', {{'c1':'Customer','c2':'US_KEY','a1':[{{'RteID':'USF2OP','EffDtRnge':{{'StrtDt':'1000-01-01','EndDt':'9999-12-31'}}}}]}}), "
+                "('{1}', {{'c3':'US_KEY'}})".format(doc_m, doc_cfl)
+            )
+            self.run_cbq_query("CREATE INDEX {0} ON default(c1,a1,c2)".format(idx1))
+            self.run_cbq_query("CREATE INDEX {0} ON default(c3)".format(idx3))
+            self.wait_for_all_indexes_online()
+
+            explain_query = (
+                "EXPLAIN SELECT COUNT(1) "
+                "FROM default AS m "
+                "LEFT JOIN default cfl ON m.c2 = cfl.c3 "
+                "WHERE m.c1 = 'Customer' "
+                "AND (ANY c IN m.a1 SATISFIES c.RteID = 'USF2OP' "
+                "AND NOW_LOCAL('1111-11-11') BETWEEN c.EffDtRnge.StrtDt AND c.EffDtRnge.EndDt END)"
+            )
+            explain = self.run_cbq_query(explain_query)
+            plan = explain['results'][0]['plan']
+            m_scan = _find_m_index_scan(plan)
+            self.assertIsNotNone(m_scan, f"Expected IndexScan3 for alias m on {idx1}, plan: {plan}")
+            self.assertTrue("filter" in m_scan, f"Expected early filter in IndexScan3, scan: {m_scan}")
+            scan_filter = m_scan["filter"]
+            self.assertTrue("Customer" in scan_filter, f"Expected c1 predicate in scan filter: {scan_filter}")
+            self.assertTrue("RteID" in scan_filter and "any" in scan_filter.lower(),
+                            f"Expected ANY predicate in scan filter: {scan_filter}")
+        finally:
+            try:
+                self.run_cbq_query("DROP INDEX default.{0}".format(idx1))
+            except Exception:
+                pass
+            try:
+                self.run_cbq_query("DROP INDEX default.{0}".format(idx3))
+            except Exception:
+                pass
+            try:
+                self.run_cbq_query("DELETE FROM default USE KEYS ['{0}','{1}']".format(doc_m, doc_cfl))
+            except Exception:
+                pass

pytests/tuqquery/tuq_sanity.py

@@ -3094,6 +3094,49 @@ def test_explain_union(self, index):
             else:
                 self.log.info("Query is not using specified index")
 
+    def test_MB70834_union_scan_for_or_predicate_with_partial_indexes(self):
+        """MB-70834: Verify union scan is correctly applied for OR predicates
+        with partial indexes."""
+        self.fail_if_no_buckets()
+        bucket = self.query_buckets[0]
+        idx_us = "idx_mb70834_us"
+        idx_uk = "idx_mb70834_uk"
+        doc_us = "mb70834_doc_us"
+        doc_uk = "mb70834_doc_uk"
+        try:
+            self.run_cbq_query(
+                "UPSERT INTO {0} (KEY, VALUE) VALUES ('{1}', {{'country':'US'}}), ('{2}', {{'country':'UK'}})".format(
+                    bucket, doc_us, doc_uk
+                )
+            )
+            self.run_cbq_query("CREATE INDEX {0} ON {1}(country) WHERE country = 'US'".format(idx_us, bucket))
+            self.run_cbq_query("CREATE INDEX {0} ON {1}(country) WHERE country = 'UK'".format(idx_uk, bucket))
+            self.wait_for_all_indexes_online()
+
+            explain = self.run_cbq_query(
+                "EXPLAIN SELECT META().id FROM {0} WHERE country = 'US' OR country = 'UK'".format(bucket)
+            )
+            explain_str = str(explain)
+            self.assertTrue("UnionScan" in explain_str, "UnionScan is not used in explain plan")
+            self.assertTrue(idx_us in explain_str and idx_uk in explain_str,
+                            "Expected partial indexes are not present in explain plan")
+        except Exception as e:
+            self.log.error(str(e))
+            self.fail()
+        finally:
+            try:
+                self.run_cbq_query("DROP INDEX {0} ON {1}".format(idx_us, bucket))
+            except Exception:
+                pass
+            try:
+                self.run_cbq_query("DROP INDEX {0} ON {1}".format(idx_uk, bucket))
+            except Exception:
+                pass
+            try:
+                self.run_cbq_query("DELETE FROM {0} USE KEYS ['{1}','{2}']".format(bucket, doc_us, doc_uk))
+            except Exception:
+                pass
+
     ##############################################################################################
     #
     #   DATETIME