@an5/orm 1.2.0 → 1.3.0

package/README.md

@@ -11,7 +11,7 @@ Runtime database connections, query building, transactions, and multi-database d
 ## Features
 
 - **Schema Definition:** Define models and relationships using concise `.an5` syntax with native database types.
-- **Multi-Language Generator:** Generate typed clients and entity models for TypeScript, Python, .NET (C#), Golang, and Rust.
+- **Multi-Language Generator:** Generate typed clients and entity models for TypeScript, Python, .NET (C#), Golang, Rust, Java, Kotlin, and Swift.
 - **Database Introspection (`db:pull`):** Inspect an existing database schema and generate matching `.an5` models.
 - **Direct Schema Push (`db:push`):** Synchronize `.an5` schema definitions directly to the database.
 - **Automated Migrations (`db:migrate`):** Diff schema against database, generate up/down migration SQL scripts, apply, rollback, and check migration status.

package/dist/generator/src/api.d.ts

@@ -25,6 +25,9 @@ export { PythonGenerator } from './python-generator';
 export { DotnetGenerator } from './dotnet-generator';
 export { GolangGenerator } from './golang-generator';
 export { RustGenerator } from './rust-generator';
+export { JavaGenerator } from './java-generator';
+export { KotlinGenerator } from './kotlin-generator';
+export { SwiftGenerator } from './swift-generator';
 export { detectProvider, providerFromConfig, providerForProject } from './config';
 export { dialectFor, defaultClause, sqlLiteral } from './dialect';
 export { fieldKind } from './type-kinds';

package/dist/generator/src/api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unknownFieldTypeMessage = exports.resolveFieldType = exports.fieldTypesFor = exports.defaultSqlTypeForTs = exports.PROVIDER_LABELS = exports.PROVIDER_FIELD_TYPES = exports.PROVIDERS = exports.FieldTypeError = exports.DEFAULT_PROVIDER = exports.prepareCodeRequest = exports.detectCodeLanguage = exports.CODE_LANGUAGES = exports.fieldKind = exports.sqlLiteral = exports.defaultClause = exports.dialectFor = exports.providerForProject = exports.providerFromConfig = exports.detectProvider = exports.RustGenerator = exports.GolangGenerator = exports.DotnetGenerator = exports.PythonGenerator = exports.MetadataGenerator = exports.CodeGenerator = exports.sqlTypeToTs = exports.SchemaParser = void 0;
+exports.unknownFieldTypeMessage = exports.resolveFieldType = exports.fieldTypesFor = exports.defaultSqlTypeForTs = exports.PROVIDER_LABELS = exports.PROVIDER_FIELD_TYPES = exports.PROVIDERS = exports.FieldTypeError = exports.DEFAULT_PROVIDER = exports.prepareCodeRequest = exports.detectCodeLanguage = exports.CODE_LANGUAGES = exports.fieldKind = exports.sqlLiteral = exports.defaultClause = exports.dialectFor = exports.providerForProject = exports.providerFromConfig = exports.detectProvider = exports.SwiftGenerator = exports.KotlinGenerator = exports.JavaGenerator = exports.RustGenerator = exports.GolangGenerator = exports.DotnetGenerator = exports.PythonGenerator = exports.MetadataGenerator = exports.CodeGenerator = exports.sqlTypeToTs = exports.SchemaParser = void 0;
 /**
  * Side-effect-free entrypoint for programmatic use of the code generator.
  *
@@ -36,6 +36,12 @@ var golang_generator_1 = require("./golang-generator");
 Object.defineProperty(exports, "GolangGenerator", { enumerable: true, get: function () { return golang_generator_1.GolangGenerator; } });
 var rust_generator_1 = require("./rust-generator");
 Object.defineProperty(exports, "RustGenerator", { enumerable: true, get: function () { return rust_generator_1.RustGenerator; } });
+var java_generator_1 = require("./java-generator");
+Object.defineProperty(exports, "JavaGenerator", { enumerable: true, get: function () { return java_generator_1.JavaGenerator; } });
+var kotlin_generator_1 = require("./kotlin-generator");
+Object.defineProperty(exports, "KotlinGenerator", { enumerable: true, get: function () { return kotlin_generator_1.KotlinGenerator; } });
+var swift_generator_1 = require("./swift-generator");
+Object.defineProperty(exports, "SwiftGenerator", { enumerable: true, get: function () { return swift_generator_1.SwiftGenerator; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "detectProvider", { enumerable: true, get: function () { return config_1.detectProvider; } });
 Object.defineProperty(exports, "providerFromConfig", { enumerable: true, get: function () { return config_1.providerFromConfig; } });

package/dist/generator/src/code-generator.js

@@ -6,6 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeGenerator = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+/**
+ * Types `resolveFieldType` can return that the SQL keyword table in
+ * `normalizeType` does not cover. Kept explicit so a new resolver output is a
+ * deliberate addition rather than silently becoming `any`.
+ */
+const RESOLVED_TS_TYPES = new Set(['Buffer', 'number | bigint', 'number[] | string']);
 class CodeGenerator {
     constructor(outputDir) {
         this.outputDir = outputDir;
@@ -238,7 +244,12 @@ export interface TableClient<T, WhereInput = any, _Select = any, Include = any,
         if (['bytes', 'binary', 'varbinary', 'image'].includes(lowerType)) {
             return 'string';
         }
-        return 'any';
+        // `Field.type` already holds the TypeScript type the parser resolved for the
+        // provider, and the resolver returns a few types this SQL table does not list:
+        // `Buffer` (BLOB), `number | bigint` (BIGINT) and `number[] | string` (VECTOR).
+        // Those used to fall through to `any`, so the generated client silently lost the
+        // type of every byte and vector column.
+        return RESOLVED_TS_TYPES.has(type) ? type : 'any';
     }
     toCamelCase(str) {
         if (!str)

package/dist/generator/src/code-request.d.ts

@@ -1,5 +1,5 @@
 import type { Provider } from './field-types';
-export declare const CODE_LANGUAGES: readonly ['typescript', 'python', 'dotnet', 'golang', 'rust'];
+export declare const CODE_LANGUAGES: readonly ['typescript', 'python', 'dotnet', 'golang', 'rust', 'java', 'kotlin', 'swift'];
 export type CodeLanguage = typeof CODE_LANGUAGES[number];
 export interface CodeRequest {
     request: string;
@@ -14,7 +14,7 @@ export declare function detectCodeLanguage(root: string): CodeLanguage;
 /** Ground the caller's model in real generated APIs; never execute user code. */
 export declare function prepareCodeRequest(input: CodeRequest): Promise<{
     status: 'context_ready';
-    language: "dotnet" | "golang" | "python" | "rust" | "typescript";
+    language: "dotnet" | "golang" | "java" | "kotlin" | "python" | "rust" | "swift" | "typescript";
     request: string;
     clientOutput: string;
     models: import("./types").Model[];

package/dist/generator/src/code-request.js

@@ -16,7 +16,10 @@ const python_generator_1 = require("./python-generator");
 const dotnet_generator_1 = require("./dotnet-generator");
 const golang_generator_1 = require("./golang-generator");
 const rust_generator_1 = require("./rust-generator");
-exports.CODE_LANGUAGES = ['typescript', 'python', 'dotnet', 'golang', 'rust'];
+const java_generator_1 = require("./java-generator");
+const kotlin_generator_1 = require("./kotlin-generator");
+const swift_generator_1 = require("./swift-generator");
+exports.CODE_LANGUAGES = ['typescript', 'python', 'dotnet', 'golang', 'rust', 'java', 'kotlin', 'swift'];
 /** Detect only the selected project, never unrelated sibling packages. */
 function detectCodeLanguage(root) {
     const names = fs_1.default.readdirSync(root);
@@ -32,6 +35,15 @@ function detectCodeLanguage(root) {
         candidates.push('golang');
     if (has('Cargo.toml'))
         candidates.push('rust');
+    // Java and Kotlin are told apart by their build file, not by a directory name: a Gradle
+    // project has both a build.gradle and a pom.xml, and only one says which language it is.
+    const hasJavaBuild = has('pom.xml') || has('build.gradle') || has('build.gradle.kts');
+    if (hasJavaBuild) {
+        const kotlinMarker = names.some((name) => /\.(kt|kts)$/.test(name)) || has('settings.gradle.kts');
+        candidates.push(kotlinMarker ? 'kotlin' : 'java');
+    }
+    if (has('Package.swift'))
+        candidates.push('swift');
     if (candidates.length !== 1)
         throw new Error(`Cannot select one project language (${candidates.join(', ') || 'none'}). Specify language explicitly or select the application directory.`);
     return candidates[0];
@@ -45,7 +57,7 @@ async function prepareCodeRequest(input) {
         throw new Error(`Unsupported language: ${language}`);
     const loaded = (0, config_1.loadConfig)(input.projectRoot);
     const output = loaded.outputs;
-    const clientOutput = { typescript: output.typescriptDir, python: path_1.default.dirname(output.pythonMetadataFile), dotnet: output.dotnetDir, golang: output.golangDir, rust: output.rustDir }[language];
+    const clientOutput = { typescript: output.typescriptDir, python: path_1.default.dirname(output.pythonMetadataFile), dotnet: output.dotnetDir, golang: output.golangDir, rust: output.rustDir, java: output.javaDir, kotlin: output.kotlinDir, swift: output.swiftDir }[language];
     const schemaPath = path_1.default.resolve(input.projectRoot, input.schemaPath);
     const schemaDir = fs_1.default.statSync(schemaPath).isDirectory() ? schemaPath : path_1.default.dirname(schemaPath);
     const scratch = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'an5-code-request-'));
@@ -76,6 +88,15 @@ async function prepareCodeRequest(input) {
             case 'rust':
                 new rust_generator_1.RustGenerator(scratch).generate(models);
                 break;
+            case 'java':
+                new java_generator_1.JavaGenerator(scratch).generate(models);
+                break;
+            case 'kotlin':
+                new kotlin_generator_1.KotlinGenerator(scratch).generate(models);
+                break;
+            case 'swift':
+                new swift_generator_1.SwiftGenerator(scratch).generate(models);
+                break;
         }
         const files = [];
         function collect(dir) {
@@ -83,7 +104,7 @@ async function prepareCodeRequest(input) {
                 const full = path_1.default.join(dir, entry.name);
                 if (entry.isDirectory())
                     collect(full);
-                else if (/\.(ts|py|cs|go|rs|mod|toml)$/.test(entry.name))
+                else if (/\.(ts|py|cs|go|rs|mod|toml|java|kt|swift)$/.test(entry.name))
                     files.push({ path: path_1.default.relative(scratch, full), content: fs_1.default.readFileSync(full, 'utf8') });
             }
         }

package/dist/generator/src/config.d.ts

@@ -19,6 +19,18 @@ export interface GolangOutput {
 export interface RustOutput {
     outputDir: string;
 }
+/** Java client output. */
+export interface JavaOutput {
+    outputDir: string;
+}
+/** Kotlin client output. */
+export interface KotlinOutput {
+    outputDir: string;
+}
+/** Swift client output. */
+export interface SwiftOutput {
+    outputDir: string;
+}
 export interface An5OrmConfig {
     /**
      * Database connection for the commands that need one — db:push, db:pull,
@@ -40,6 +52,9 @@ export interface An5OrmConfig {
         dotnet: DotnetOutput;
         golang: GolangOutput;
         rust: RustOutput;
+        java: JavaOutput;
+        kotlin: KotlinOutput;
+        swift: SwiftOutput;
     };
     pull: {
         /** Regex patterns; tables matching any of them are skipped by db:pull. */
@@ -62,6 +77,9 @@ export interface ResolvedOutputs {
     dotnetDir: string;
     golangDir: string;
     rustDir: string;
+    javaDir: string;
+    kotlinDir: string;
+    swiftDir: string;
 }
 export declare function resolveOutputs(config: An5OrmConfig, rootDir: string): ResolvedOutputs;
 /**

package/dist/generator/src/config.js

@@ -40,6 +40,9 @@ exports.DEFAULT_CONFIG = {
         dotnet: { outputDir: 'an5Client/dotnet' },
         golang: { outputDir: 'an5Client/golang' },
         rust: { outputDir: 'an5Client/rust' },
+        java: { outputDir: 'an5Client/java' },
+        kotlin: { outputDir: 'an5Client/kotlin' },
+        swift: { outputDir: 'an5Client/swift' },
     },
     pull: {
         exclude: ['^__', '^sys\\.', '^igrations'],
@@ -59,6 +62,9 @@ function resolveOutputs(config, rootDir) {
         dotnetDir: resolve(config.outputs.dotnet.outputDir),
         golangDir: resolve(config.outputs.golang.outputDir),
         rustDir: resolve(config.outputs.rust.outputDir),
+        javaDir: resolve(config.outputs.java.outputDir),
+        kotlinDir: resolve(config.outputs.kotlin.outputDir),
+        swiftDir: resolve(config.outputs.swift.outputDir),
     };
 }
 class ConfigError extends Error {
@@ -136,6 +142,9 @@ const OUTPUT_SPEC = {
     dotnet: 'object',
     golang: 'object',
     rust: 'object',
+    java: 'object',
+    kotlin: 'object',
+    swift: 'object',
 };
 const OUTPUT_SECTION_SPEC = {
     typescript: { outputDir: 'string', metadataFile: 'string' },
@@ -143,6 +152,9 @@ const OUTPUT_SECTION_SPEC = {
     dotnet: { outputDir: 'string' },
     golang: { outputDir: 'string' },
     rust: { outputDir: 'string' },
+    java: { outputDir: 'string' },
+    kotlin: { outputDir: 'string' },
+    swift: { outputDir: 'string' },
 };
 const TOP_LEVEL_SPEC = {
     connectionString: 'string',
@@ -203,6 +215,18 @@ function validateConfig(raw) {
                 outputDir: outputs.rust?.outputDir ??
                     exports.DEFAULT_CONFIG.outputs.rust.outputDir,
             },
+            java: {
+                outputDir: outputs.java?.outputDir ??
+                    exports.DEFAULT_CONFIG.outputs.java.outputDir,
+            },
+            kotlin: {
+                outputDir: outputs.kotlin?.outputDir ??
+                    exports.DEFAULT_CONFIG.outputs.kotlin.outputDir,
+            },
+            swift: {
+                outputDir: outputs.swift?.outputDir ??
+                    exports.DEFAULT_CONFIG.outputs.swift.outputDir,
+            },
         },
         pull: {
             exclude: pull.exclude ?? exports.DEFAULT_CONFIG.pull.exclude,

package/dist/generator/src/dialect.js

@@ -197,13 +197,15 @@ function createDialect(provider, quote) {
     // destructured by a caller.
     const columnDefinition = (column) => {
         const identity = identityKeyword(column, provider);
+        const sqlType = provider === 'sqlite' && /^VECTOR\s*(\(|$)/i.test(column.sqlType)
+            ? 'BLOB' : column.sqlType;
         // Where the identity keyword goes is not a detail: SQL Server takes it as part
         // of the column type (`INT IDENTITY(1,1)`), while SQLite only accepts it after
         // `PRIMARY KEY` and only spells the documented form `INTEGER PRIMARY KEY
         // AUTOINCREMENT`.
         const type = identity && provider !== 'sqlite'
-            ? `${quote(column.name)} ${column.sqlType} ${identity}`
-            : `${quote(column.name)} ${column.sqlType}`;
+            ? `${quote(column.name)} ${sqlType} ${identity}`
+            : `${quote(column.name)} ${sqlType}`;
         const nullable = column.isOptional ? '' : ' NOT NULL';
         const unique = column.isUnique && !column.isId ? ' UNIQUE' : '';
         const defaultSql = defaultClause(column.defaultExpr, provider);

package/dist/generator/src/dotnet-generator.js

@@ -289,6 +289,7 @@ using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
+using System.Linq;
 using System.Reflection;
 using System.Text.Json;
 using An5Orm.Entities;
@@ -377,11 +378,41 @@ namespace An5Orm
         {
             var p = cmd.CreateParameter();
             p.ParameterName = (name ?? "").TrimStart('@');
-            p.Value = value ?? DBNull.Value;
+            p.Value = Bindable(value) ?? DBNull.Value;
             cmd.Parameters.Add(p);
             return p;
         }
 
+        /// <summary>
+        /// Converts a value into something the provider can bind.
+        /// </summary>
+        /// <remarks>
+        /// A <c>VECTOR(n)</c> column is transmitted as a JSON array over TDS, so a float or
+        /// double array is written in that form. The array itself is not bindable: the
+        /// provider has no mapping for it, and the failure names the array rather than the
+        /// column it was meant for.
+        /// </remarks>
+        public static object Bindable(object value)
+        {
+            // \`float[]\` and \`double[]\` are listed separately rather than through a shared
+            // \`IEnumerable<double>\`: an array of value type is not covariant, so
+            // \`float[]\` does not convert to it.
+            if (value is float[] floats) return FormatVector(floats.Select(v => (double)v));
+            if (value is double[] doubles) return FormatVector(doubles);
+            return value;
+        }
+
+        /// <summary>Renders a vector as the JSON array SQL Server expects.</summary>
+        public static string FormatVector(IEnumerable<double> vector)
+        {
+            var parts = new List<string>();
+            foreach (var value in vector)
+            {
+                parts.Add(value.ToString("R", System.Globalization.CultureInfo.InvariantCulture));
+            }
+            return "[" + string.Join(", ", parts) + "]";
+        }
+
         /// <summary>Quotes an identifier for the dialect.</summary>
         public static string Quote(string name, An5Dialect dialect)
         {
@@ -1006,6 +1037,60 @@ namespace An5Orm
         /// property would otherwise fail to set. A value that cannot be
         /// converted is skipped rather than aborting the whole read.
         /// </summary>
+        /// <summary>
+        /// Reads a stored vector into the \`float[]\` an entity declares.
+        /// </summary>
+        /// <remarks>
+        /// A \`VECTOR(n)\` column arrives as a JSON array over TDS, so the JSON form is
+        /// what is parsed. A float32 BLOB is also accepted because that is what the SQLite
+        /// provider stores in the same column. Returns <c>null</c> for anything else, which
+        /// leaves the property at its default rather than aborting the whole read.
+        /// </remarks>
+        private static float[] DecodeVectorColumn(object value)
+        {
+            if (value is float[] already) return already;
+            if (value is double[] asDouble)
+            {
+                var fromDouble = new float[asDouble.Length];
+                for (int i = 0; i < asDouble.Length; i++) fromDouble[i] = (float)asDouble[i];
+                return fromDouble;
+            }
+
+            string text = value as string;
+            byte[] bytes = value as byte[];
+            if (bytes != null && bytes.Length > 0 && bytes[0] != (byte)'[' && bytes.Length % 4 == 0)
+            {
+                var fromBlob = new float[bytes.Length / 4];
+                for (int i = 0; i < fromBlob.Length; i++)
+                {
+                    int offset = i * 4;
+                    uint bits = (uint)(bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24));
+                    fromBlob[i] = BitConverter.ToSingle(BitConverter.GetBytes(bits), 0);
+                }
+                return fromBlob;
+            }
+            if (text == null && bytes != null)
+            {
+                text = System.Text.Encoding.UTF8.GetString(bytes);
+            }
+            if (text == null) return null;
+
+            var open = text.IndexOf('[');
+            var close = text.LastIndexOf(']');
+            if (open < 0 || close <= open) return null;
+            var body = text.Substring(open + 1, close - open - 1).Trim();
+            if (body.Length == 0) return null;
+
+            var parts = body.Split(',');
+            var parsed = new float[parts.Length];
+            for (int i = 0; i < parts.Length; i++)
+            {
+                if (!float.TryParse(parts[i].Trim(), System.Globalization.NumberStyles.Float,
+                    System.Globalization.CultureInfo.InvariantCulture, out parsed[i])) return null;
+            }
+            return parsed;
+        }
+
         private static void SetValue(System.Reflection.PropertyInfo prop, object target, object value)
         {
             var wanted = prop.PropertyType;
@@ -1023,6 +1108,17 @@ namespace An5Orm
                     prop.SetValue(target, Convert.ChangeType(value, underlying));
                     return;
                 }
+                // A \`VECTOR(n)\` column is transmitted as a JSON array over TDS, which no
+                // converter bridges to the \`float[]\` the entity declares.
+                if (wanted == typeof(float[]))
+                {
+                    var vector = DecodeVectorColumn(value);
+                    if (vector != null)
+                    {
+                        prop.SetValue(target, vector);
+                        return;
+                    }
+                }
                 if (value is string text && wanted == typeof(Guid)) { prop.SetValue(target, Guid.Parse(text)); return; }
                 if (value is string when && wanted == typeof(DateTime)) { prop.SetValue(target, DateTime.Parse(when, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.RoundtripKind)); return; }
                 prop.SetValue(target, Convert.ChangeType(value, wanted));

package/dist/generator/src/field-types.js

@@ -255,6 +255,9 @@ exports.PROVIDER_FIELD_TYPES = {
         // Everything else
         JSON: 'any',
         UUID: 'string',
+        // Stored as a BLOB of little-endian float32: a third of the JSON text it replaces,
+        // and what the adapters' in-database distance functions read. A column already
+        // holding JSON text keeps working, because the adapters decode both.
         VECTOR: 'number[] | string',
     },
     // ─── Google Sheets ─────────────────────────────────────────────────────────

package/dist/generator/src/golang-generator.d.ts

@@ -23,6 +23,14 @@ export declare class GolangGenerator {
     private generateDbContext;
     private generateTableClientStruct;
     private generateQueryAndScan;
+    /**
+     * The vector codec the generated client needs on both sides of a query.
+     *
+     * A \`VECTOR(n)\` column stores float32 bytes, which is a third of the JSON text it
+     * replaces and is what the in-database distance functions read. A column written
+     * before that encoding holds JSON text, so both are still accepted on the way in.
+     */
+    private generateVectorHelpers;
     private generateWhereBuilder;
     private generateCrudMethods;
     private generateVectorSearch;

package/dist/generator/src/golang-generator.js

@@ -186,6 +186,7 @@ func GetDefaultConnectionString() string {
         content += this.generateWhereBuilder();
         content += this.generateCrudMethods();
         content += this.generateVectorSearch();
+        content += this.generateVectorHelpers();
         content += this.generateHelpers();
         // NOTE: per-model ORM types live in each `<Model>.go` file.
         fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'client.go'), content);
@@ -401,9 +402,18 @@ func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ..
 \t\tvar item T
 \t\tval := reflect.ValueOf(&item).Elem()
 \t\tscanArgs := make([]interface{}, len(cols))
+\t\tvectorCols := make([]bool, len(cols))
 \t\tfor i, colName := range cols {
 \t\t\tfieldVal := findFieldByDbTag(val, colName)
 \t\t\tif fieldVal.IsValid() && fieldVal.CanSet() {
+\t\t\t\t// A \`VECTOR(n)\` column is stored as bytes, which database/sql cannot
+\t\t\t\t// scan into a slice, so it is read as bytes and decoded afterwards.
+\t\t\t\tif isVectorGoType(fieldVal.Type()) {
+\t\t\t\t\tvar raw []byte
+\t\t\t\t\tscanArgs[i] = &raw
+\t\t\t\t\tvectorCols[i] = true
+\t\t\t\t\tcontinue
+\t\t\t\t}
 \t\t\t\tscanArgs[i] = fieldVal.Addr().Interface()
 \t\t\t} else {
 \t\t\t\tvar unused interface{}
@@ -413,6 +423,20 @@ func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ..
 \t\tif err := rows.Scan(scanArgs...); err != nil {
 \t\t\treturn nil, err
 \t\t}
+\t\tfor i, isVector := range vectorCols {
+\t\t\tif !isVector {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tdecoded, ok := decodeVectorBytes(*(scanArgs[i].(*[]byte)))
+\t\t\tif !ok {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tfieldVal := findFieldByDbTag(val, cols[i])
+\t\t\tif !fieldVal.IsValid() || !fieldVal.CanSet() {
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tsetVectorField(fieldVal, decoded)
+\t\t}
 \t\tresults = append(results, item)
 \t}
 \tif err := rows.Err(); err != nil {
@@ -421,6 +445,160 @@ func (c *TableClient[T]) queryAndScan(ctx context.Context, query string, args ..
 \treturn results, nil
 }
 
+`;
+    }
+    /**
+     * The vector codec the generated client needs on both sides of a query.
+     *
+     * A \`VECTOR(n)\` column stores float32 bytes, which is a third of the JSON text it
+     * replaces and is what the in-database distance functions read. A column written
+     * before that encoding holds JSON text, so both are still accepted on the way in.
+     */
+    generateVectorHelpers() {
+        return `// bytesPerVectorFloat is the width of one stored vector component.
+const bytesPerVectorFloat = 4
+
+// isVectorGoType reports whether a model field is a vector column, which the
+// generator declares as a float32 slice, optionally behind a pointer because the
+// column is nullable.
+func isVectorGoType(t reflect.Type) bool {
+\treturn vectorSliceType(t) != nil
+}
+
+// vectorSliceType returns the slice type a vector field holds, or nil for any
+// other field. A pointer to a slice is unwrapped so both the nullable and the
+// required spelling are recognised.
+func vectorSliceType(t reflect.Type) reflect.Type {
+\tif t.Kind() == reflect.Ptr {
+\t\tt = t.Elem()
+\t}
+\tif t.Kind() == reflect.Slice && t.Elem().Kind() == reflect.Float32 {
+\t\treturn t
+\t}
+\treturn nil
+}
+
+// vectorComponents reads a vector field as float64 components.
+//
+// A field can arrive as JSON text, as a slice, or behind a pointer to either, and a
+// pointer is how the generator spells a nullable column. Anything else is not a vector.
+func vectorComponents(field reflect.Value) []float64 {
+\tfor field.Kind() == reflect.Ptr {
+\t\tif field.IsNil() {
+\t\t\treturn nil
+\t\t}
+\t\tfield = field.Elem()
+\t}
+\tswitch {
+\tcase field.Kind() == reflect.String:
+\t\tvar parsed []float64
+\t\tif err := json.Unmarshal([]byte(field.String()), &parsed); err != nil {
+\t\t\treturn nil
+\t\t}
+\t\treturn parsed
+\tcase field.Kind() == reflect.Slice:
+\t\tout := make([]float64, field.Len())
+\t\tfor i := range out {
+\t\t\tout[i] = field.Index(i).Float()
+\t\t}
+\t\treturn out
+\tdefault:
+\t\treturn nil
+\t}
+}
+
+// setVectorField stores decoded components into a vector field, matching whether
+// the field holds the slice directly or behind a pointer.
+func setVectorField(field reflect.Value, values []float64) {
+\tsliceType := vectorSliceType(field.Type())
+\tif sliceType == nil {
+\t\treturn
+\t}
+\tslice := reflect.MakeSlice(sliceType, len(values), len(values))
+\tfor i, value := range values {
+\t\tslice.Index(i).SetFloat(value)
+\t}
+\tif field.Kind() == reflect.Ptr {
+\t\tptr := reflect.New(sliceType)
+\t\tptr.Elem().Set(slice)
+\t\tfield.Set(ptr)
+\t\treturn
+\t}
+\tfield.Set(slice)
+}
+
+// encodeVectorArg converts a vector field into the bytes the column stores.
+//
+// database/sql accepts only a fixed set of types, so a slice otherwise reaches the
+// driver as an error. Values that already arrived as stored form pass through.
+func encodeVectorArg(value interface{}) interface{} {
+\tswitch v := value.(type) {
+\tcase *[]float32:
+\t\tif v == nil {
+\t\t\treturn nil
+\t\t}
+\t\treturn encodeVectorFloats(floatsFrom32(*v))
+\tcase []float32:
+\t\treturn encodeVectorFloats(floatsFrom32(v))
+\tcase *[]float64:
+\t\tif v == nil {
+\t\t\treturn nil
+\t\t}
+\t\treturn encodeVectorFloats(*v)
+\tcase []float64:
+\t\treturn encodeVectorFloats(v)
+\tdefault:
+\t\treturn value
+\t}
+}
+
+func floatsFrom32(values []float32) []float64 {
+\tout := make([]float64, len(values))
+\tfor i, value := range values {
+\t\tout[i] = float64(value)
+\t}
+\treturn out
+}
+
+// encodeVectorFloats writes float32 values little-endian, which is the order the
+// stored bytes are read back in.
+func encodeVectorFloats(values []float64) []byte {
+\tout := make([]byte, len(values)*bytesPerVectorFloat)
+\tfor i, value := range values {
+\t\toffset := i * bytesPerVectorFloat
+\t\tbits := math.Float32bits(float32(value))
+\t\tout[offset] = byte(bits)
+\t\tout[offset+1] = byte(bits >> 8)
+\t\tout[offset+2] = byte(bits >> 16)
+\t\tout[offset+3] = byte(bits >> 24)
+\t}
+\treturn out
+}
+
+// decodeVectorBytes reads a stored vector: float32 bytes, legacy JSON text, or
+// nothing at all.
+func decodeVectorBytes(raw []byte) ([]float64, bool) {
+\tif len(raw) == 0 {
+\t\treturn nil, false
+\t}
+\t// JSON text is not a multiple of four bytes once encoded and starts with '[',
+\t// so the two are told apart by length and first byte.
+\tif raw[0] == '[' || len(raw)%bytesPerVectorFloat != 0 {
+\t\tvar parsed []float64
+\t\tif err := json.Unmarshal(raw, &parsed); err != nil || len(parsed) == 0 {
+\t\t\treturn nil, false
+\t\t}
+\t\treturn parsed, true
+\t}
+\tout := make([]float64, len(raw)/bytesPerVectorFloat)
+\tfor i := range out {
+\t\toffset := i * bytesPerVectorFloat
+\t\tbits := uint32(raw[offset]) | uint32(raw[offset+1])<<8 | uint32(raw[offset+2])<<16 | uint32(raw[offset+3])<<24
+\t\tout[i] = float64(math.Float32frombits(bits))
+\t}
+\treturn out, true
+}
+
 `;
     }
     // ─── WHERE builder ─────────────────────────────────────────────────────────
@@ -637,7 +815,7 @@ func (c *TableClient[T]) Create(ctx context.Context, entity *T) (*T, error) {
 \t\tfieldVal := val.Field(i)
 \t\tif !fieldVal.IsZero() {
 \t\t\tcols = append(cols, c.quoteName(dbTag))
-\t\t\targs = append(args, fieldVal.Interface())
+\t\t\targs = append(args, encodeVectorArg(fieldVal.Interface()))
 \t\t\tphs = append(phs, c.ph(len(args)))
 \t\t}
 \t}
@@ -684,7 +862,7 @@ func (c *TableClient[T]) Update(ctx context.Context, entity *T) (*T, error) {
 \t\t\tidVal = fieldVal.Interface()
 \t\t\tidCol = dbTag
 \t\t} else if !fieldVal.IsZero() {
-\t\t\targs = append(args, fieldVal.Interface())
+\t\t\targs = append(args, encodeVectorArg(fieldVal.Interface()))
 \t\t\tsets = append(sets, c.quoteName(dbTag)+" = "+c.ph(len(args)))
 \t\t}
 \t}
@@ -1031,13 +1209,9 @@ func (c *TableClient[T]) VectorSearch(ctx context.Context, vector []float64, opt
 \t\t\tcontinue
 \t\t}
 
-\t\tvar rowVec []float64
-\t\tif fieldVal.Kind() == reflect.String {
-\t\t\t_ = json.Unmarshal([]byte(fieldVal.String()), &rowVec)
-\t\t} else if fieldVal.Kind() == reflect.Slice {
-\t\t\tfor i := 0; i < fieldVal.Len(); i++ {
-\t\t\t\trowVec = append(rowVec, fieldVal.Index(i).Float())
-\t\t\t}
+\t\trowVec := vectorComponents(fieldVal)
+\t\tif len(rowVec) == 0 {
+\t\t\tcontinue
 \t\t}
 \t\tif len(rowVec) != len(vector) {
 \t\t\tcontinue