refactor error messages and use qualified names for matching

Author: tomas-villagesql

mysql-test/suite/villagesql/create_table/r/create_table_complex_functional_index.result

@@ -35,12 +35,12 @@ Table	Op	Msg_type	Msg_text
 test.t1	analyze	status	OK
 EXPLAIN SELECT id FROM t1 WHERE COMPLEX_ABS(sig) = CAST(30.0 AS DOUBLE);
 id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	NULL	ref	idx_magnitude	idx_magnitude	9	const	1	100.00	NULL
+1	SIMPLE	t1	NULL	ref	idx_magnitude	idx_magnitude	9	#	#	#	NULL
 Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`id` AS `id` from `test`.`t1` where (vsql_complex.complex_abs(`sig`) = cast(30.0 as double))
 EXPLAIN SELECT id FROM t1 WHERE vsql_complex.COMPLEX_ABS(sig) > CAST(20.0 AS DOUBLE);
 id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
-1	SIMPLE	t1	NULL	range	idx_magnitude	idx_magnitude	9	NULL	3	100.00	Using where
+1	SIMPLE	t1	NULL	range	idx_magnitude	idx_magnitude	9	#	#	#	Using where
 Warnings:
 Note	1003	/* select#1 */ select `test`.`t1`.`id` AS `id` from `test`.`t1` where (vsql_complex.complex_abs(`sig`) > <cache>(cast(20.0 as double)))
 SELECT id FROM t1 WHERE COMPLEX_ABS(sig) = CAST(30.0 AS DOUBLE);

mysql-test/suite/villagesql/create_table/t/create_table_complex_functional_index.test

@@ -37,7 +37,10 @@ ANALYZE TABLE t1;
 # Test index usage with WHERE clauses on functions
 # Triggering usage of functional indexes is hard, the cast to double is needed
 # for the optimizer to match and use the index
+# rows and filtered are optimizer estimates that vary by platform/run
+--replace_column 9 # 10 # 11 #
 EXPLAIN SELECT id FROM t1 WHERE COMPLEX_ABS(sig) = CAST(30.0 AS DOUBLE);
+--replace_column 9 # 10 # 11 #
 EXPLAIN SELECT id FROM t1 WHERE vsql_complex.COMPLEX_ABS(sig) > CAST(20.0 AS DOUBLE);
 
 SELECT id FROM t1 WHERE COMPLEX_ABS(sig) = CAST(30.0 AS DOUBLE);

mysql-test/suite/villagesql/select/r/select_function_complex.result

@@ -25,7 +25,7 @@ conjugate_imag
 -2.71828
 -4
 SELECT vsql_complex.complex_real(complex2_col) AS real_part FROM t1 ORDER BY complex2_col;
-ERROR HY000: Cannot initialize function 'complex_real': argument 1 type mismatch (expected COMPLEX, got COMPLEX2)
+ERROR HY000: Cannot initialize function 'complex_real': argument 1 type mismatch (expected vsql_complex.COMPLEX, got vsql_complex.COMPLEX2)
 SELECT vsql_complex.complex_real(str_col) AS real_part FROM t1 ORDER BY str_col;
 ERROR HY000: Cannot initialize function 'complex_real': argument 1 must be a custom type or string constant
 SELECT vsql_complex.complex_real(int_col) AS real_part FROM t1 ORDER BY int_col;

sql/field.h

@@ -1968,6 +1968,9 @@ class Create_field_wrapper final : public Field {
     return new (mem_root) Create_field_wrapper(*this);
   }
   bool is_wrapper_field() const final { return true; }
+  // VillageSQL: used to check custom_type_context during functional index
+  // validation before the table exists.
+  const Create_field *get_create_field() const { return m_field; }
   /* purecov: end */
 };
 

villagesql/schema/descriptor/type_context.cc

@@ -29,6 +29,9 @@
 namespace villagesql {
 
 void TypeContext::resolve_cached_values() {
+  // Build qualified_base_name_ once: "ext.type" (no parameters)
+  qualified_base_name_ = descriptor_->qualified_base_name();
+
   // Build qualified_name_ once: "ext.type" or "ext.type(v1,v2,...)"
   // TODO(villagesql): This needs to be updated to support both TYPE(N) and
   // TYPE('k1=v1,k2=v2,...') syntax, and to preserve parameter order as defined

villagesql/schema/descriptor/type_context.h

@@ -229,6 +229,10 @@ class TypeContext {
   // Returns "extension_name.type_name" or "extension_name.type_name(v1,v2,...)"
   // when parameters are present (e.g. "vsql_tvector.TVECTOR(3)").
   const std::string &qualified_name() const { return qualified_name_; }
+  // Returns "extension_name.type_name" without parameters
+  const std::string &qualified_base_name() const {
+    return qualified_base_name_;
+  }
 
   // Storage characteristics for this type instantiation.
   // For fixed-length types, these are copied from the TypeDescriptor.
@@ -250,6 +254,7 @@ class TypeContext {
 
   // Cached values (computed eagerly in resolve_cached_values())
   std::string qualified_name_;
+  std::string qualified_base_name_;
   int64_t persisted_length_{0};
   int64_t max_decode_buffer_length_{0};
 };

villagesql/types/util.cc

@@ -1029,18 +1029,25 @@ bool ValidateAndConvertVDFArguments(THD *thd, const char *func_name,
       continue;
     }
 
+    // Build the expected qualified base name ("extension.TYPE") once for use
+    // in Cases 1 and 3. This ensures a TYPE from extension A is not accepted
+    // by a VDF from extension B that also declares the same TYPE.
+    // expected_type.custom_type is always non-null for VEF_TYPE_CUSTOM params
+    // (enforced by the SDK).
+    assert(expected_type.custom_type != nullptr);
+    const std::string expected_qbn =
+        std::string(extension_name.str, extension_name.length) + "." +
+        expected_type.custom_type;
+
+    // Case 1: Argument already has custom type - validate compatibility.
     auto *tc = args[i]->get_type_context();
-
-    // Case 1: Argument already has custom type - validate compatibility
     if (tc != nullptr) {
-      const char *expected_type_name = expected_type.custom_type;
-      if (expected_type_name != nullptr &&
-          tc->type_name() != expected_type_name) {
+      if (tc->qualified_base_name() != expected_qbn) {
         villagesql_error(
             "Cannot initialize function '%s': argument %u type mismatch "
             "(expected %s, got %s)",
-            MYF(0), func_name, i + 1, expected_type_name,
-            tc->type_name().c_str());
+            MYF(0), func_name, i + 1, expected_qbn.c_str(),
+            tc->qualified_base_name().c_str());
         return true;
       }
       continue;
@@ -1049,19 +1056,10 @@ bool ValidateAndConvertVDFArguments(THD *thd, const char *func_name,
     // Case 2: Argument is a constant string - try implicit conversion
     if (args[i]->type() == Item::STRING_ITEM &&
         args[i]->const_for_execution()) {
-      const char *custom_type_name = expected_type.custom_type;
-      if (custom_type_name == nullptr) {
-        villagesql_error(
-            "Cannot initialize function '%s': invalid function signature for "
-            "argument %u",
-            MYF(0), func_name, i + 1);
-        return true;
-      }
-
       // Resolve the custom type by extension and type name
       LEX_STRING lex_type_name;
-      lex_type_name.str = const_cast<char *>(custom_type_name);
-      lex_type_name.length = strlen(custom_type_name);
+      lex_type_name.str = const_cast<char *>(expected_type.custom_type);
+      lex_type_name.length = strlen(expected_type.custom_type);
 
       const TypeContext *type_ctx = nullptr;
       // TODO(villagesql-beta): pass real TypeParameters for parameterized types
@@ -1075,7 +1073,7 @@ bool ValidateAndConvertVDFArguments(THD *thd, const char *func_name,
         villagesql_error(
             "Cannot initialize function '%s': custom type '%s' not found for "
             "argument %u",
-            MYF(0), func_name, custom_type_name, i + 1);
+            MYF(0), func_name, expected_type.custom_type, i + 1);
         return true;
       }
 
@@ -1088,11 +1086,38 @@ bool ValidateAndConvertVDFArguments(THD *thd, const char *func_name,
 
     // Case 3: Argument is a column reference (Item_field) without type context
     // yet. This happens during functional index creation: the table is being
-    // created, so the field's custom type context hasn't been injected yet.
-    // Allow it through; at execution time the field will carry its type context
-    // and marshal_args() will pass the binary data correctly.
+    // created, so MaybeInjectCustomType hasn't run yet. The field's underlying
+    // Create_field_wrapper (set by replace_field_processor) lets us check
+    // whether the column will actually be a custom type.
+    // We match on qualified_base_name() (extension.type, no parameters),
+    // consistent with Case 1, because VDF signatures cannot express type
+    // parameterization - a VDF declared with param("TVECTOR") must accept any
+    // TVECTOR(N) column.
     if (args[i]->type() == Item::FIELD_ITEM) {
-      continue;
+      auto *item_field = down_cast<Item_field *>(args[i]);
+      if (item_field->field != nullptr &&
+          item_field->field->is_wrapper_field()) {
+        auto *wrapper =
+            down_cast<const Create_field_wrapper *>(item_field->field);
+        const Create_field *cf = wrapper->get_create_field();
+        if (cf->custom_type_context != nullptr) {
+          if (cf->custom_type_context->qualified_base_name() != expected_qbn) {
+            villagesql_error(
+                "Cannot initialize function '%s': argument %u type mismatch "
+                "(expected %s, got %s)",
+                MYF(0), func_name, i + 1, expected_qbn.c_str(),
+                cf->custom_type_context->qualified_base_name().c_str());
+            return true;
+          }
+          continue;
+        }
+      }
+      // Column has no custom type context - reject it
+      villagesql_error(
+          "Cannot initialize function '%s': argument %u must be a custom type "
+          "or string constant",
+          MYF(0), func_name, i + 1);
+      return true;
     }
 
     // Case 4: Argument is not a custom type and not a constant string