vef: add stateful encoder to Field/Item (#66)

TypeEncoder ia a per-Field or Item object that holds encoding state
across rows. Previously, every encode call allocated a new output buffer
from mem_root; now a single scratch buffer (sized to persisted_length)
is allocated once and reused for the lifetime of the Field's TABLE or
the Item's query execution.

For VDF-based encode ops, the VDF call structures (vef_invalue_t,
vef_vdf_args_t, vef_vdf_result_t) are pre-filled at construction time,
so only the per-row fields (input pointer/length, result type) are
touched on each call. 

TypeEncoder is lazily created via GetTypeEncoderFor and cached on the
Field or Item. Item::cleanup() nulls the pointer between
prepared-statement re-executions so a fresh encoder is allocated on the
new thd->mem_root next execution.  Temporary table encoders are tied to
the TABLE_SHARE::mem_root of the temporary table.

The public encode API in util.h is simplified: callers no longer pass
MEM_ROOT, field_name, or TypeContext — the encoder resolves these from
the Field or Item itself.

Author: malone-at-work

mysql-test/suite/villagesql/ps/r/ps_encode_context_reuse_complex.result

@@ -0,0 +1,18 @@
+CREATE TABLE t1 (id INT, val COMPLEX);
+INSERT INTO t1 VALUES (1,'(1.0,2.0)'),(2,'(3.0,4.0)'),(3,'(5.0,6.0)'),(4,'(1.0,2.0)');
+PREPARE stmt FROM 'SELECT id FROM t1 WHERE val = ? ORDER BY id';
+SET @p = '(1,2)';
+EXECUTE stmt USING @p;
+id
+1
+4
+SET @p = '(3,4)';
+EXECUTE stmt USING @p;
+id
+2
+SET @p = '(5,6)';
+EXECUTE stmt USING @p;
+id
+3
+DEALLOCATE PREPARE stmt;
+DROP TABLE t1;

mysql-test/suite/villagesql/ps/t/ps_encode_context_reuse_complex.test

@@ -0,0 +1,31 @@
+# Test that EncodeContext on Item_param is correctly reset between PS
+# re-executions. Item_param persists across executions on the PS mem_root,
+# while thd->mem_root (where the EncodeContext is allocated) is cleared between
+# executions. Item::cleanup() nulls encode_context_ at execution end so the
+# next execution lazily re-allocates on the fresh thd->mem_root. Without this
+# reset, re-execution would use a dangling pointer and produce wrong results.
+
+--source include/villagesql/install_complex_extension.inc
+
+CREATE TABLE t1 (id INT, val COMPLEX);
+INSERT INTO t1 VALUES (1,'(1.0,2.0)'),(2,'(3.0,4.0)'),(3,'(5.0,6.0)'),(4,'(1.0,2.0)');
+
+# Execute the same prepared statement three times with different parameter
+# values. Each execution must encode the new string correctly using a fresh
+# EncodeContext, not a stale pointer from a prior execution.
+PREPARE stmt FROM 'SELECT id FROM t1 WHERE val = ? ORDER BY id';
+
+SET @p = '(1,2)';
+EXECUTE stmt USING @p;
+
+SET @p = '(3,4)';
+EXECUTE stmt USING @p;
+
+SET @p = '(5,6)';
+EXECUTE stmt USING @p;
+
+DEALLOCATE PREPARE stmt;
+
+DROP TABLE t1;
+
+--source include/villagesql/uninstall_complex_extension.inc

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

@@ -0,0 +1,19 @@
+CREATE TABLE t1 (id INT, val COMPLEX);
+INSERT INTO t1 VALUES (1,'(1.0,2.0)'),(2,'(3.0,4.0)'),(3,'(5.0,6.0)'),(4,'(1.0,2.0)');
+SELECT t_outer.id, t_outer.val
+FROM t1 AS t_outer
+WHERE t_outer.val = (SELECT t_inner.val FROM t1 AS t_inner
+WHERE t_inner.id = t_outer.id LIMIT 1);
+id	val
+1	(1,2)
+2	(3,4)
+3	(5,6)
+4	(1,2)
+SELECT t_outer.id, t_outer.val
+FROM t1 AS t_outer
+WHERE t_outer.val IN (SELECT t_inner.val FROM t1 AS t_inner
+WHERE t_inner.id != t_outer.id);
+id	val
+1	(1,2)
+4	(1,2)
+DROP TABLE t1;

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

@@ -0,0 +1,9 @@
+CREATE TABLE t1 (val vsql_complex.COMPLEX);
+INSERT INTO t1 VALUES ('(1.0, 2.0)'), ('(3.0, 4.0)');
+# String literal unioned with COMPLEX column: encoder runs on tmp table field
+SELECT '(5.0, 6.0)' AS val UNION SELECT val FROM t1 ORDER BY val;
+val
+(1,2)
+(3,4)
+(5,6)
+DROP TABLE t1;

mysql-test/suite/villagesql/select/t/select_subquery_self_join_complex.test

@@ -0,0 +1,33 @@
+# Test correlated subqueries where outer and inner scans reference the same
+# table. MySQL must open two TABLE instances from the same TABLE_SHARE, giving
+# each its own cloned Field objects and independent EncodeContext/buffer. If
+# the same TABLE instance were incorrectly reused for both scans, buffer
+# aliasing would corrupt encoded values and produce wrong comparison results.
+
+--source include/villagesql/install_complex_extension.inc
+
+CREATE TABLE t1 (id INT, val COMPLEX);
+INSERT INTO t1 VALUES (1,'(1.0,2.0)'),(2,'(3.0,4.0)'),(3,'(5.0,6.0)'),(4,'(1.0,2.0)');
+
+# Scalar correlated subquery on the same table.
+# Inner scan encodes val for each row with matching id; outer scan compares.
+# Expected: all 4 rows (outer val always equals inner val for same id).
+# If the outer and inner scans shared a buffer, the inner scan would overwrite
+# the outer val before the comparison, producing wrong results.
+SELECT t_outer.id, t_outer.val
+FROM t1 AS t_outer
+WHERE t_outer.val = (SELECT t_inner.val FROM t1 AS t_inner
+                     WHERE t_inner.id = t_outer.id LIMIT 1);
+
+# IN correlated subquery on the same table.
+# Expected: rows 1 and 4 only (both have val=(1,2); each has a peer with a
+# different id that also has val=(1,2)).
+# If buffer aliasing occurred, cross-row comparisons would be wrong.
+SELECT t_outer.id, t_outer.val
+FROM t1 AS t_outer
+WHERE t_outer.val IN (SELECT t_inner.val FROM t1 AS t_inner
+                      WHERE t_inner.id != t_outer.id);
+
+DROP TABLE t1;
+
+--source include/villagesql/uninstall_complex_extension.inc

mysql-test/suite/villagesql/select/t/select_union_literal_encode_complex.test

@@ -0,0 +1,19 @@
+# Regression test: encoding a string literal into a UNION result tmp table's
+# COMPLEX field must not allocate the TypeEncoder on TABLE::mem_root.
+#
+# A UNION where one arm is a string literal and the other is a COMPLEX column
+# forces GetTypeEncoderFor() to run on the UNION result tmp table's Field.
+# With the bug, close_tmp_table() asserts table->mem_root.allocated_size() == 0
+# in debug builds because the encoder was allocated there.
+
+--source include/villagesql/install_complex_extension.inc
+
+CREATE TABLE t1 (val vsql_complex.COMPLEX);
+INSERT INTO t1 VALUES ('(1.0, 2.0)'), ('(3.0, 4.0)');
+
+--echo # String literal unioned with COMPLEX column: encoder runs on tmp table field
+SELECT '(5.0, 6.0)' AS val UNION SELECT val FROM t1 ORDER BY val;
+
+DROP TABLE t1;
+
+--source include/villagesql/uninstall_complex_extension.inc

sql/field.h

@@ -63,6 +63,10 @@
 #include "template_utils.h"
 #include "villagesql/schema/descriptor/type_context.h"
 
+namespace villagesql {
+class TypeEncoder;
+}  // namespace villagesql
+
 class Create_field;
 class CostOfItem;
 class Field;
@@ -1885,14 +1889,21 @@ class Field {
   const uchar *unpack_int64(uchar *to, const uchar *from) const;
 
  private:
+  // TODO(villagesql): Collapse these into one object (here and in Item)
   const villagesql::TypeContext *custom_type{nullptr};
+  villagesql::TypeEncoder *type_encoder_{nullptr};
 
  public:
   const villagesql::TypeContext *get_type_context() const {
     return custom_type;
   }
   void set_type_context(const villagesql::TypeContext *tc) { custom_type = tc; }
   bool has_type_context() const { return nullptr != custom_type; }
+
+  villagesql::TypeEncoder *get_type_encoder() const { return type_encoder_; }
+  void set_type_encoder(villagesql::TypeEncoder *encoder) {
+    type_encoder_ = encoder;
+  }
 };
 
 /**

sql/item.cc

@@ -4331,8 +4331,7 @@ type_conversion_status Item_param::save_in_field_inner(Field *field,
       return TYPE_OK;
     case MYSQL_TYPE_VARCHAR: {
       if (field->has_type_context()) {
-        return villagesql::EncodeAndStoreStringToCustomField(
-            *field->get_type_context(), str_value, field);
+        return villagesql::EncodeAndStoreStringToCustomField(str_value, field);
       }
       return field->store(str_value.ptr(), str_value.length(),
                           str_value.charset());
@@ -4492,8 +4491,8 @@ String *Item_param::val_str(String *str) {
   switch (data_type_actual()) {
     case MYSQL_TYPE_VARCHAR: {
       if (has_type_context()) {
-        return villagesql::EncodeStringForCustomParam(
-            *get_type_context(), str_value_ptr, item_name.ptr(), null_value);
+        return villagesql::EncodeStringForCustomParam(this, str_value_ptr,
+                                                      null_value);
       }
       return &str_value_ptr;
     }
@@ -7062,9 +7061,8 @@ type_conversion_status Item::save_in_field_inner(Field *field,
     // For custom types, encode the string value before storing
     if (!has_type_context() && field->has_type_context()) {
       bool is_valid = false;
-      String *encoded = villagesql::EncodeStringForField(
-          *field->get_type_context(), *result, *current_thd->mem_root,
-          field->field_name, is_valid);
+      String *encoded =
+          villagesql::EncodeStringForField(field, *result, is_valid);
       if (encoded == nullptr) {
         str_value.set_quick(nullptr, 0, cs);
         return is_valid ? TYPE_ERR_OOM : TYPE_ERR_BAD_VALUE;
@@ -7113,8 +7111,8 @@ type_conversion_status Item_string::save_in_field_inner(Field *field, bool) {
 
     // Encode str_value into a new representation, based on the type.
     bool is_oom = false;
-    String *encoded = villagesql::EncodeStringForField(
-        *tc, str_value, *current_thd->mem_root, field->field_name, is_oom);
+    String *encoded =
+        villagesql::EncodeStringForField(field, str_value, is_oom);
     if (encoded == nullptr) {
       return is_oom ? TYPE_ERR_OOM : TYPE_ERR_BAD_VALUE;
     }

sql/item.h

@@ -79,6 +79,10 @@
 #include "template_utils.h"
 #include "villagesql/include/item_helpers.h"
 
+namespace villagesql {
+class TypeEncoder;
+}  // namespace villagesql
+
 class Item;
 class Item_field;
 class Item_func;
@@ -1277,7 +1281,10 @@ class Item : public Parse_tree_node {
     Prepare for new execution by clearing cached values.
     Do not remove values allocated during preparation, destructor handles this.
   */
-  virtual void cleanup() { marker = MARKER_NONE; }
+  virtual void cleanup() {
+    marker = MARKER_NONE;
+    type_encoder_ = nullptr;
+  }
   /**
     Called when an item has been removed, can be used to notify external
     objects about the removal, e.g subquery predicates that are part of
@@ -3748,13 +3755,18 @@ class Item : public Parse_tree_node {
 
  protected:
   const villagesql::TypeContext *custom_type{nullptr};
+  villagesql::TypeEncoder *type_encoder_{nullptr};
 
  public:
   virtual const villagesql::TypeContext *get_type_context() const {
     return custom_type;
   }
   void set_type_context(const villagesql::TypeContext *tc) { custom_type = tc; }
   virtual bool has_type_context() const { return nullptr != custom_type; }
+  villagesql::TypeEncoder *get_type_encoder() const { return type_encoder_; }
+  void set_type_encoder(villagesql::TypeEncoder *encoder) {
+    type_encoder_ = encoder;
+  }
 };
 
 /**

sql/sql_load.cc

@@ -1482,9 +1482,8 @@ bool Sql_cmd_load_table::read_sep_field(THD *thd, COPY_INFO &info,
         if (field->has_type_context()) {
           String input_str((char *)pos, length, read_info.read_charset);
           bool is_valid = false;
-          String *encoded = villagesql::EncodeStringForField(
-              *field->get_type_context(), input_str, *thd->mem_root,
-              field->field_name, is_valid);
+          String *encoded =
+              villagesql::EncodeStringForField(field, input_str, is_valid);
           if (encoded == nullptr) {
             if (is_valid) return true;  // OOM case
             // Encoding failed - in strict mode, fail; otherwise skip row
@@ -1733,9 +1732,8 @@ bool Sql_cmd_load_table::read_xml_field(THD *thd, COPY_INFO &info,
         if (field->has_type_context()) {
           String input_str(tag->value.ptr(), tag->value.length(), cs);
           bool is_valid = false;
-          String *encoded = villagesql::EncodeStringForField(
-              *field->get_type_context(), input_str, *thd->mem_root,
-              field->field_name, is_valid);
+          String *encoded =
+              villagesql::EncodeStringForField(field, input_str, is_valid);
           if (encoded == nullptr) {
             if (is_valid) return true;  // OOM case
             // Encoding failed - in strict mode, fail; otherwise skip row