Add GROUP_CONCAT support for custom types (#464)

GitOrigin-RevId: 8b58a2336b2bec40d8da4f8cda0f45e61ac854b2

Author: tomas-villagesql

mysql-test/suite/villagesql/aggregation/r/group_concat_basic.result

@@ -0,0 +1,27 @@
+CREATE TABLE complex_test (
+id INT PRIMARY KEY,
+value vsql_complex.COMPLEX
+);
+INSERT INTO complex_test VALUES
+(1, '(3.0, 4.0)'),
+(2, '(1.0, 2.0)'),
+(3, '(5.0, 1.0)'),
+(4, '(2.0, 3.0)'),
+(5, '(1.0, 2.0)');
+# Basic GROUP_CONCAT (no ORDER BY, no GROUP BY)
+SELECT GROUP_CONCAT(value) FROM complex_test;
+GROUP_CONCAT(value)
+(3,4),(1,2),(5,1),(2,3),(1,2)
+# GROUP_CONCAT with constant (tests const_item branch)
+SELECT GROUP_CONCAT('(1.0, 2.0)');
+GROUP_CONCAT('(1.0, 2.0)')
+(1.0, 2.0)
+# GROUP_CONCAT with DISTINCT (tests field path with uniqueness)
+SELECT GROUP_CONCAT(DISTINCT value) FROM complex_test;
+GROUP_CONCAT(DISTINCT value)
+(1,2),(2,3),(3,4),(5,1)
+# GROUP_CONCAT with const-folded function call (tests const_item with custom type)
+SELECT GROUP_CONCAT(complex_from_string('(6.0, 7.0)'));
+GROUP_CONCAT(complex_from_string('(6.0, 7.0)'))
+(6,7)
+DROP TABLE complex_test;

mysql-test/suite/villagesql/aggregation/t/group_concat_basic.test

@@ -0,0 +1,31 @@
+# Test GROUP_CONCAT() on COMPLEX custom type
+
+--source include/villagesql/install_complex_extension.inc
+
+CREATE TABLE complex_test (
+  id INT PRIMARY KEY,
+  value vsql_complex.COMPLEX
+);
+
+INSERT INTO complex_test VALUES
+  (1, '(3.0, 4.0)'),
+  (2, '(1.0, 2.0)'),
+  (3, '(5.0, 1.0)'),
+  (4, '(2.0, 3.0)'),
+  (5, '(1.0, 2.0)');
+
+--echo # Basic GROUP_CONCAT (no ORDER BY, no GROUP BY)
+SELECT GROUP_CONCAT(value) FROM complex_test;
+
+--echo # GROUP_CONCAT with constant (tests const_item branch)
+SELECT GROUP_CONCAT('(1.0, 2.0)');
+
+--echo # GROUP_CONCAT with DISTINCT (tests field path with uniqueness)
+SELECT GROUP_CONCAT(DISTINCT value) FROM complex_test;
+
+--echo # GROUP_CONCAT with const-folded function call (tests const_item with custom type)
+SELECT GROUP_CONCAT(complex_from_string('(6.0, 7.0)'));
+
+DROP TABLE complex_test;
+
+--source include/villagesql/uninstall_complex_extension.inc

mysql-test/suite/villagesql/implicit_cast/disallowed/r/aggregate_group_concat_complex.result

@@ -1029,6 +1029,13 @@ class Field {
   // types always decode binary data to a new string (never returning existing
   // string data), so the two-buffer optimization doesn't apply.
   String *val_custom_str(String *buf) const;
+  String *val_custom_str(String *str, uchar *new_ptr) {
+    uchar *old_ptr = ptr;
+    ptr = new_ptr;
+    String *result = val_custom_str(str);
+    ptr = old_ptr;
+    return result;
+  }
   String *val_int_as_str(String *val_buffer, bool unsigned_flag) const;
   /*
    str_needs_quotes() returns true if the value returned by val_str() needs

mysql-test/suite/villagesql/implicit_cast/disallowed/t/aggregate_group_concat_complex.test

@@ -287,7 +287,7 @@ String *Item::val_str_ascii(String *str) {
 String *Item::val_custom_str(String *str) {
   // Get binary data from val_str()
   String *binary_data = val_str(str);
-  if (!binary_data || null_value) return binary_data;
+  if (!has_type_context() || null_value) return binary_data;
 
   // Decode using TypeContext's to_string function
   bool is_valid = true;

sql/field.h

@@ -721,6 +721,16 @@ Field *Item_sum::create_tmp_field(bool, TABLE *table) {
   return field;
 }
 
+Field *Item_sum::make_string_field(TABLE *table) const {
+  Field *field = Item::make_string_field(table);
+  // VillageSQL: Propagate TypeContext from aggregated argument to result field.
+  // This allows GROUP_CONCAT to decode custom type values when building output.
+  if (field && arg_count > 0 && args[0]->has_type_context()) {
+    field->set_type_context(args[0]->get_type_context());
+  }
+  return field;
+}
+
 bool Item_sum::collect_grouped_aggregates(uchar *arg) {
   auto *info = pointer_cast<Collect_grouped_aggregate_info *>(arg);
 
@@ -4170,17 +4180,20 @@ int dump_leaf_key(void *key_arg, element_count count [[maybe_unused]],
       We also can't use table->field array to access the fields
       because it contains both order and arg list fields.
      */
-    if ((*arg)->const_item())
-      res = (*arg)->val_str(&tmp);
-    else {
+    // VillageSQL: Use val_custom_str throughout to decode custom types.
+    // Const items can have custom types (e.g., const-folded function calls).
+    if ((*arg)->const_item()) {
+      res = (*arg)->val_custom_str(&tmp);
+    } else {
       Field *field = (*arg)->get_tmp_table_field();
       if (field) {
         const uint offset =
             (field->offset(field->table->record[0]) - table->s->null_bytes);
         assert(offset < table->s->reclength);
-        res = field->val_str(&tmp, key + offset);
-      } else
-        res = (*arg)->val_str(&tmp);
+        res = field->val_custom_str(&tmp, key + offset);
+      } else {
+        res = (*arg)->val_custom_str(&tmp);
+      }
     }
     if (res) result->append(*res);
   }

sql/item.cc

@@ -616,6 +616,8 @@ class Item_sum : public Item_func {
   }
   virtual void make_unique() { force_copy_fields = true; }
   virtual Field *create_tmp_field(bool group, TABLE *table);
+  // VillageSQL: Override to propagate TypeContext from aggregated argument
+  Field *make_string_field(TABLE *table) const override;
 
   /// argument used by walk method collect_grouped_aggregates ("cga")
   struct Collect_grouped_aggregate_info {

sql/item_sum.cc

@@ -863,11 +863,13 @@ bool CheckCustomTypeUsage(Item *item, THD *thd) {
     // Check if any arg is custom type
     for (uint i = 0; i < sum_func->arg_count; i++) {
       if (sum_func->get_arg(i)->has_type_context()) {
-        // Some aggregates work automatically via the type's compare function
+        // Some aggregates work automatically via the type's compare/decode
+        // functions
         switch (sum_func->sum_func()) {
           case Item_sum::MIN_FUNC:
           case Item_sum::MAX_FUNC:
           case Item_sum::COUNT_DISTINCT_FUNC:
+          case Item_sum::GROUP_CONCAT_FUNC:
             continue;  // Allow these aggregates on custom types
           default:
             // Block all other aggregate functions on custom types