ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/sqlite/index.js

@@ -2,16 +2,30 @@
 /**
  * SQLite dialect implementation
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteTransaction = exports.SQLiteDialect = void 0;
 exports.createSQLiteDialect = createSQLiteDialect;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const operators_1 = require("../../operators");
+// Lazily-loaded `better-sqlite3` driver. This native addon is only loaded the
+// first time a connection is opened, so importing this ORM never dlopens the
+// better-sqlite3 native binding.
+let betterSqlite3Ctor = null;
+function loadBetterSqlite3() {
+    if (!betterSqlite3Ctor) {
+        try {
+            betterSqlite3Ctor = require('better-sqlite3');
+        }
+        catch (err) {
+            throw new Error("The 'better-sqlite3' package is required to use the SQLite dialect but could not be loaded. " +
+                'Install it with `npm install better-sqlite3`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return betterSqlite3Ctor;
+}
 const stream_1 = require("stream");
 const prorm_1 = require("../../prorm");
-const operators_1 = require("../../operators");
+const operators_2 = require("../../operators");
 const sqlite_advanced_1 = require("../../sqlite-advanced");
 /**
  * SQLite dialect class that implements the Dialect interface
@@ -40,7 +54,7 @@ class SQLiteDialect {
                 timeout: this.config.timeout || 5000,
                 verbose: this.config.verbose || undefined,
             };
-            this.connection = new better_sqlite3_1.default(this.config.storage, options);
+            this.connection = new (loadBetterSqlite3())(this.config.storage, options);
             this._isConnected = true;
             // Enable foreign keys by default
             this.connection.pragma('foreign_keys = ON');
@@ -722,9 +736,13 @@ class SQLiteDialect {
                 let fkSql = `${name}FOREIGN KEY (${fields}) `;
                 // Handle composite foreign keys (string | string[])
                 const refField = constraint.references.field;
+                // Both branches must parenthesize - the single-column case previously
+                // emitted `REFERENCES "users""id"` (no parens, and the two quoted
+                // identifiers running together), which SQLite rejects as a syntax error.
+                // Every other dialect wraps this branch; sqlite was the outlier.
                 const refFieldSql = Array.isArray(refField)
                     ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
-                    : this.escapeId(refField);
+                    : `(${this.escapeId(refField)})`;
                 fkSql += `REFERENCES ${this.escapeId(constraint.references.table)}${refFieldSql}`;
                 if (constraint.references.onDelete) {
                     fkSql += ` ON DELETE ${constraint.references.onDelete}`;
@@ -1178,32 +1196,110 @@ class SQLiteDialect {
      * @param options - VACUUM options
      */
     async vacuum(options) {
-        return this.advanced.vacuum(options);
+        // Inlined (async) so it also works over the Turso/libSQL wire.
+        let sql = 'VACUUM';
+        if (options?.schema)
+            sql += ` ${options.schema}`;
+        if (options?.shrinkTo !== undefined)
+            sql += ` INTO 'shrink_${options.shrinkTo}.db'`;
+        await this.query(sql);
+        if (options?.analyze)
+            await this.analyze();
     }
     /**
      * ANALYZE the database - updates statistics for query optimizer
      * @param target - Optional table or index name
      */
     async analyze(target) {
-        return this.advanced.analyze(target);
+        await this.query(target ? `ANALYZE ${this.escapeId(target)}` : 'ANALYZE');
     }
     /**
      * Get database information using PRAGMA
      */
     async getDatabaseInfo() {
-        return this.advanced.getDatabaseInfo();
+        // Inlined via async PRAGMA queries so it also works over Turso/libSQL.
+        const pragma = async (name) => (await this.query(`PRAGMA ${name}`)).rows[0];
+        const [sv, uv, fk, jm, sy, cs, ps] = await Promise.all([
+            pragma('schema_version'),
+            pragma('user_version'),
+            pragma('foreign_keys'),
+            pragma('journal_mode'),
+            pragma('synchronous'),
+            pragma('cache_size'),
+            pragma('page_size'),
+        ]);
+        return {
+            schemaVersion: sv?.schema_version,
+            userVersion: uv?.user_version,
+            foreignKeys: fk?.foreign_keys === 1,
+            journalingMode: jm?.journal_mode,
+            synchronous: sy?.synchronous,
+            cacheSize: cs?.cache_size,
+            pageSize: ps?.page_size,
+        };
     }
     /**
      * Create an FTS5 virtual table for full-text search
      */
     async createFTS5Table(tableName, columns, options) {
-        return this.advanced.createFTS5Table(tableName, columns, options);
+        // Built inline (rather than delegating to the sync `.advanced` API) so
+        // this works over any async connection, including the Turso/libSQL wire
+        // (which has no synchronous better-sqlite3 handle to back `.advanced`).
+        const columnDefs = columns
+            .map((col) => {
+            let def = this.escapeId(col.name);
+            if (col.type)
+                def += ` ${col.type}`;
+            if (col.notindexed)
+                def += ' NOTINDEXED';
+            return def;
+        })
+            .join(', ');
+        let sql = `CREATE VIRTUAL TABLE ${this.escapeId(tableName)} USING fts5(${columnDefs}`;
+        if (options?.tokenizer) {
+            sql += `, tokenize='${options.tokenizer}'`;
+        }
+        if (options?.content) {
+            sql += `, content='${options.content}'`;
+        }
+        if (options?.contentRowId) {
+            sql += `, content_rowid='${options.contentRowId}'`;
+        }
+        if (options?.prefix) {
+            sql += `, prefix='${Array.isArray(options.prefix) ? options.prefix.join(' ') : options.prefix}'`;
+        }
+        sql += ')';
+        await this.query(sql);
     }
     /**
      * Perform full-text search
      */
     async fullTextSearch(ftsTable, searchQuery, options) {
-        return this.advanced.fullTextSearch(ftsTable, searchQuery, options);
+        // Built inline so it works over any async connection (incl. Turso/libSQL).
+        let sql = 'SELECT';
+        if (options?.bm25) {
+            sql += ` bm25(${this.escapeId(ftsTable)}) AS score, `;
+        }
+        else {
+            sql += ' 0 AS score, ';
+        }
+        if (options?.highlight) {
+            const col = options.highlight.column || '*';
+            sql += ` highlight(${this.escapeId(ftsTable)}, ${options.columns?.indexOf(col) ?? 0}${options.highlight.before ? `, '${options.highlight.before}'` : ''}${options.highlight.after ? `, '${options.highlight.after}'` : ''}) AS highlighted, `;
+        }
+        sql += options?.columns?.map((c) => this.escapeId(c)).join(', ') || '*';
+        sql += ` FROM ${this.escapeId(ftsTable)}`;
+        sql += ` WHERE ${this.escapeId(ftsTable)} MATCH ?`;
+        if (options?.orderBy) {
+            sql += ` ORDER BY ${options.orderBy
+                .map((o) => `${this.escapeId(o.column)}${o.desc ? ' DESC' : ''}`)
+                .join(', ')}`;
+        }
+        if (options?.limit)
+            sql += ` LIMIT ${options.limit}`;
+        if (options?.offset)
+            sql += ` OFFSET ${options.offset}`;
+        return this.query(sql, { replacements: [searchQuery] });
     }
     // ==================== Stored Procedures ====================
     // SQLite does not support stored procedures natively
@@ -1360,19 +1456,42 @@ class SQLiteDialect {
      * Create a trigger
      */
     async createTrigger(triggerName, timing, events, tableName, body, options) {
-        return this.advanced.createTrigger(triggerName, timing, events, tableName, body, options);
+        // Built inline (rather than delegating to the sync `.advanced` API) so
+        // triggers can be created over any async connection, including Turso/libSQL.
+        // SQLite has no `CREATE OR REPLACE TRIGGER`; emulate `replace` by dropping first.
+        if (options?.replace) {
+            await this.dropTrigger(triggerName, { ifExists: true });
+        }
+        let sql = `CREATE TRIGGER ${this.escapeId(triggerName)}`;
+        sql += ` ${timing} ${(events || []).join(' OR ')} ON ${this.escapeId(tableName)}`;
+        if (options?.forEachRow)
+            sql += ' FOR EACH ROW';
+        if (options?.whenCondition)
+            sql += ` WHEN ${options.whenCondition}`;
+        sql += `\nBEGIN\n${body}\nEND`;
+        await this.query(sql);
     }
     /**
      * Drop a trigger
      */
     async dropTrigger(triggerName, options) {
-        return this.advanced.dropTrigger(triggerName, options);
+        let sql = 'DROP TRIGGER';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.escapeId(triggerName)}`;
+        await this.query(sql);
     }
-    async hasTrigger(_triggerName, _tableName) {
-        // Check if trigger exists
-        const sql = `SELECT name FROM sqlite_master WHERE type='trigger' AND name=?`;
-        const result = await this.query(sql, { plain: true });
-        return !!result;
+    async hasTrigger(triggerName, tableName) {
+        // Bind the trigger name (the previous implementation passed `{ plain: true }`
+        // as the options object, so the `?` placeholder was never bound and the
+        // check matched *any* trigger). Optionally scope to a table.
+        const sql = tableName
+            ? `SELECT name FROM sqlite_master WHERE type='trigger' AND name = ? AND tbl_name = ?`
+            : `SELECT name FROM sqlite_master WHERE type='trigger' AND name = ?`;
+        const result = await this.query(sql, {
+            replacements: tableName ? [triggerName, tableName] : [triggerName],
+        });
+        return result.rows.length > 0;
     }
     // ==================== Sequences ====================
     // SQLite does not have native sequences, but they can be simulated
@@ -2009,7 +2128,7 @@ class SQLiteDialect {
             const topSymbols = Object.getOwnPropertySymbols(rawCond);
             const normalizedCond = { ...rawCond };
             for (const sym of topSymbols) {
-                const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                const strKey = (0, operators_2.operatorToWhereKey)(sym);
                 if (strKey)
                     normalizedCond[strKey] = rawCond[sym];
             }
@@ -2064,7 +2183,7 @@ class SQLiteDialect {
                     const symbolKeys = Object.getOwnPropertySymbols(rawValueObj);
                     const normalizedObj = { ...rawValueObj };
                     for (const sym of symbolKeys) {
-                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        const strKey = (0, operators_2.operatorToWhereKey)(sym);
                         if (strKey)
                             normalizedObj[strKey] = rawValueObj[sym];
                     }
@@ -2546,6 +2665,15 @@ class SQLiteDialect {
     /**
      * Check if a value is a literal expression (literal('sql'))
      */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    literalSql(expr) {
+        return (0, operators_1.expandLiteralBindings)(expr, (v) => this.escape(v));
+    }
     isLiteralExpression(value) {
         return value !== null && typeof value === 'object' && value.__type === 'literal';
     }
@@ -2589,7 +2717,7 @@ class SQLiteDialect {
                         sql = this.escapeId(expr.col);
                     }
                     else if (this.isLiteralExpression(expr)) {
-                        sql = expr.sql;
+                        sql = this.literalSql(expr);
                     }
                     else if (typeof expr === 'string') {
                         // Check if it's a column reference or literal SQL
@@ -2613,7 +2741,7 @@ class SQLiteDialect {
                     return this.escapeId(attr.col);
                 }
                 else if (this.isLiteralExpression(attr)) {
-                    return attr.sql;
+                    return this.literalSql(attr);
                 }
                 else if (typeof attr === 'string') {
                     // Plain column name
@@ -2653,7 +2781,7 @@ class SQLiteDialect {
                     sql = this.escapeId(expr.col);
                 }
                 else if (this.isLiteralExpression(expr)) {
-                    sql = expr.sql;
+                    sql = this.literalSql(expr);
                 }
                 else if (typeof expr === 'string') {
                     sql = this.escapeId(expr);
@@ -2674,7 +2802,7 @@ class SQLiteDialect {
                 return this.escapeId(field.col);
             }
             else if (this.isLiteralExpression(field)) {
-                return field.sql;
+                return this.literalSql(field);
             }
             else if (typeof field === 'string') {
                 if (field.includes('.')) {
@@ -2879,7 +3007,7 @@ class SQLiteDialect {
             // older { val }/{ fn }/{ col }/{ literal } shapes) and end up stringified
             // as "[object Object]", producing invalid SQL like "[object Object] AS alias".
             if (attr && typeof attr === 'object' && attr.__type === 'literal' && typeof attr.sql === 'string') {
-                return attr.sql;
+                return this.literalSql(attr);
             }
             if (attr && typeof attr === 'object' && attr.__type === 'col' && typeof attr.col === 'string') {
                 return this.escapeId(attr.col);
@@ -3211,9 +3339,7 @@ class SQLiteDialect {
         const lastParen = createSql.lastIndexOf(')');
         const newCreateSql = createSql.slice(0, lastParen).trimEnd() + `,\n  ${fkClause}\n` + createSql.slice(lastParen);
         const tmpName = `${tableName}__fk_rebuild`;
-        // Setter PRAGMAs don't return rows, so run them via exec() rather than query()
-        // (which would try stmt.all() and throw "statement does not return data").
-        this.connection?.exec('PRAGMA foreign_keys=OFF');
+        await this.setPragma('foreign_keys=OFF');
         try {
             await this.query(`ALTER TABLE ${this.quoteTable(tableName)} RENAME TO ${this.escapeId(tmpName)}`);
             await this.query(newCreateSql);
@@ -3221,9 +3347,21 @@ class SQLiteDialect {
             await this.query(`DROP TABLE ${this.escapeId(tmpName)}`);
         }
         finally {
-            this.connection?.exec('PRAGMA foreign_keys=ON');
+            await this.setPragma('foreign_keys=ON');
         }
     }
+    /**
+     * Run a setter PRAGMA (one that returns no rows).
+     *
+     * On better-sqlite3 this must go through the synchronous `exec()` API:
+     * routing it through `query()` would call `stmt.all()` and throw
+     * "statement does not return data". Subclasses that don't have a
+     * synchronous connection (e.g. TursoDialect over the libSQL wire) override
+     * this to run the PRAGMA through their async driver instead.
+     */
+    async setPragma(pragma) {
+        this.connection?.exec(`PRAGMA ${pragma}`);
+    }
     /**
      * Rename a column
      */

package/dist/dialects/tidb/index.d.ts

@@ -0,0 +1,226 @@
+/**
+ * TiDB dialect implementation for the TypeScript ORM
+ *
+ * TiDB is MySQL-wire-protocol compatible: it speaks the MySQL client/server
+ * protocol and understands (almost all of) MySQL's SQL grammar, so this
+ * dialect extends {@link MySQLDialect} and reuses MySQL's `mysql2` driver
+ * verbatim (connection pooling, escaping, query execution, streaming, most
+ * DDL/DML builders). Only the genuine TiDB grammar differences are overridden
+ * or added here.
+ *
+ * Differences from plain MySQL implemented in this dialect:
+ *
+ * - **Dialect identity**: `name` is `'tidb'` (the wire `library` stays
+ *   `'mysql2'` since that's the actual driver in use).
+ * - **Default port 4000**: TiDB's default SQL port is 4000, not MySQL's 3306.
+ *   The constructor injects it as a default that the caller can still override.
+ * - **AUTO_RANDOM primary keys**: TiDB offers `AUTO_RANDOM` as an alternative
+ *   to `AUTO_INCREMENT` for (BIGINT) primary keys. It scatters generated IDs
+ *   across the key space to avoid the write hot-spotting that a monotonic
+ *   `AUTO_INCREMENT` key causes on a range-partitioned distributed store. A
+ *   column flag (`autoRandom: true` or `autoRandom: <shardBits>`) emits
+ *   `AUTO_RANDOM` / `AUTO_RANDOM(n)` instead of `AUTO_INCREMENT`.
+ * - **SHARD_ROW_ID_BITS / PRE_SPLIT_REGIONS**: TiDB table options (for tables
+ *   without an integer PK) that shard the implicit `_tidb_rowid` and
+ *   pre-split the table into multiple regions up front to spread write load.
+ *   Both are supported as CREATE TABLE options and are not valid MySQL syntax.
+ * - **SPLIT TABLE**: TiDB-only statement to pre-split a table/index's key
+ *   range into N regions (`SPLIT TABLE t BETWEEN (...) AND (...) REGIONS n`).
+ *   Not standard MySQL, so it's exposed as a dedicated helper.
+ * - **Storage engines**: TiDB parses but effectively ignores MySQL
+ *   storage-engine clauses such as `ENGINE=InnoDB` (all TiDB tables live in
+ *   its distributed KV store / TiKV; there is no per-table pluggable engine).
+ *   The `engine` table option is still emitted for MySQL source compatibility,
+ *   but has no effect on TiDB — documented here so callers don't rely on it.
+ */
+import { MySQLDialect, MySQLDialectOptions } from '../mysql/index';
+import { ColumnDefinition, TableOptions, InsertOptions } from '../dialect';
+import { DataType } from '../../types';
+/**
+ * TiDB connection options. Identical to {@link MySQLDialectOptions} (the same
+ * `mysql2` driver is used); declared as its own type for clarity and so the
+ * default port can differ.
+ */
+export interface TiDBDialectOptions extends MySQLDialectOptions {
+}
+/**
+ * TiDB-specific column definition: adds `autoRandom`, TiDB's alternative to
+ * `AUTO_INCREMENT` for primary-key columns.
+ */
+export interface TiDBColumnDefinition extends ColumnDefinition {
+    /**
+     * Emit `AUTO_RANDOM` instead of `AUTO_INCREMENT` for this (BIGINT primary
+     * key) column. `true` emits a bare `AUTO_RANDOM`; a number emits
+     * `AUTO_RANDOM(n)` where `n` is the shard-bit count. Takes precedence over
+     * `autoIncrement` when both are set.
+     */
+    autoRandom?: boolean | number;
+}
+/**
+ * TiDB-specific CREATE TABLE options: `SHARD_ROW_ID_BITS` and
+ * `PRE_SPLIT_REGIONS`. Both are TiDB extensions (not valid in MySQL).
+ */
+export interface TiDBTableOptions extends TableOptions {
+    /**
+     * `SHARD_ROW_ID_BITS = n` — number of bits used to shard the implicit
+     * `_tidb_rowid` for tables that have no integer primary key (or a non-clustered
+     * PK), spreading inserts across regions instead of appending to one hot region.
+     */
+    shardRowIdBits?: number;
+    /**
+     * `PRE_SPLIT_REGIONS = n` — pre-split the table into 2^n regions at creation
+     * time (used together with `SHARD_ROW_ID_BITS` / `AUTO_RANDOM`) so the write
+     * load is distributed immediately rather than after the table grows.
+     */
+    preSplitRegions?: number;
+}
+/**
+ * Options for {@link TiDBDialect.buildSplitTableSql} / {@link TiDBDialect.splitTable}.
+ */
+export interface TiDBSplitTableOptions {
+    /**
+     * Inclusive lower and upper bound of the key range to split, as a
+     * `[lower, upper]` tuple. Each element is emitted inside `(...)` — a single
+     * value, or a comma-joined list for composite keys.
+     */
+    between: [unknown | unknown[], unknown | unknown[]];
+    /** Number of regions to split the range into. */
+    regions: number;
+    /**
+     * Optional index name. When provided, splits that index's key range
+     * (`SPLIT TABLE t INDEX idx BETWEEN ...`) instead of the table's row range.
+     */
+    index?: string;
+}
+/**
+ * TiDB dialect. MySQL-wire-compatible; reuses the `mysql2` driver via
+ * {@link MySQLDialect}. See the file header for the full list of differences.
+ */
+export declare class TiDBDialect extends MySQLDialect {
+    readonly name = "tidb";
+    constructor(config?: TiDBDialectOptions);
+    /**
+     * Build the column-definition SQL fragment for a single column, with TiDB's
+     * `AUTO_RANDOM` support. MySQL's own column builder is `private`, so this
+     * dialect implements its own (covering the same common flags) rather than
+     * reusing it.
+     */
+    private buildColumnSql;
+    /** Escape single quotes/backslashes for embedding a string literal. */
+    private escapeSqlString;
+    /** Render a column DEFAULT value. */
+    private formatDefaultValue;
+    /**
+     * Build a TiDB `CREATE TABLE` statement, supporting `AUTO_RANDOM` primary
+     * keys and the `SHARD_ROW_ID_BITS` / `PRE_SPLIT_REGIONS` table options.
+     * Pure/synchronous — returns the SQL string without executing it.
+     */
+    buildCreateTableSql(tableName: string, columns: Record<string, TiDBColumnDefinition>, options?: TiDBTableOptions): string;
+    /**
+     * Create a table using TiDB grammar (AUTO_RANDOM, SHARD_ROW_ID_BITS,
+     * PRE_SPLIT_REGIONS). Overrides the MySQL implementation, whose private
+     * column builder cannot emit `AUTO_RANDOM`.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Build an INSERT query. Identical to the MySQL builder except that when
+     * `options.upsert` is set, the `ON DUPLICATE KEY UPDATE` clause uses the
+     * TiDB-compatible `VALUES(col)` function form rather than MySQL 8.0.19's
+     * row-alias (`AS new_vals`) form, which TiDB rejects.
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT query using TiDB-compatible `ON DUPLICATE KEY UPDATE col =
+     * VALUES(col)` syntax (the base MySQL dialect emits the row-alias form that
+     * TiDB does not accept). TiDB, like MySQL, has no `RETURNING` clause.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: {
+        conflictFields?: string[];
+        updateOnDuplicate?: string[];
+        returning?: boolean | string[];
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Map an ORM {@link DataType} to TiDB column SQL. Delegates to the MySQL
+     * mapping for everything TiDB shares, but rejects the spatial/GIS types up
+     * front: TiDB implements no spatial data types (GEOMETRY, POINT, POLYGON,
+     * …), so emitting them would produce a `CREATE TABLE` that a real TiDB
+     * server rejects. Failing here gives a clear, actionable error instead of
+     * an opaque server-side parse error.
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build an `ALTER TABLE ... ADD CONSTRAINT` statement (synchronous).
+     */
+    buildAddConstraintSql(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): string;
+    /**
+     * Build an `ALTER TABLE ... DROP ...` statement for a constraint
+     * (synchronous). TiDB (like MySQL) drops each constraint kind with a
+     * different clause, so the caller passes the constraint `type`; when omitted
+     * a generic `DROP CONSTRAINT` (valid for CHECK constraints) is emitted.
+     */
+    buildDropConstraintSql(tableName: string, constraintName: string, type?: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY'): string;
+    /**
+     * Add a constraint to an existing table (TiDB supports this; MySQL base
+     * throws). Executes {@link buildAddConstraintSql}.
+     */
+    addConstraint(tableName: string, options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    /**
+     * Drop a constraint from a table by name. Emits a generic
+     * `ALTER TABLE ... DROP CONSTRAINT name` (valid on TiDB for CHECK
+     * constraints); for foreign keys / unique keys / primary keys use
+     * {@link buildDropConstraintSql} with an explicit `type`.
+     */
+    removeConstraint(tableName: string, constraintName: string): Promise<void>;
+    /**
+     * TiDB implements no spatial/GIS data types, so a spatial index has nothing
+     * to index and a real server rejects it. Fail up front with a clear,
+     * actionable error (mirrors {@link getDataTypeSql}'s spatial-type rejection)
+     * instead of surfacing an opaque server-side parse error.
+     */
+    createSpatialIndex(_tableName: string, _indexName: string, _fields: string[], _options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * Build a TiDB `SPLIT TABLE` statement. This pre-splits a table's (or an
+     * index's) key range into `regions` regions, distributing write load before
+     * data arrives. Not standard MySQL. Pure/synchronous.
+     *
+     * @example
+     * // SPLIT TABLE `t` BETWEEN (0) AND (1000000) REGIONS 16
+     * dialect.buildSplitTableSql('t', { between: [0, 1000000], regions: 16 });
+     */
+    buildSplitTableSql(tableName: string, options: TiDBSplitTableOptions): string;
+    /**
+     * Execute a {@link buildSplitTableSql} statement.
+     */
+    splitTable(tableName: string, options: TiDBSplitTableOptions): Promise<void>;
+}
+/**
+ * Convenience factory mirroring `createMySQLDialect`.
+ */
+export declare function createTiDBDialect(options?: TiDBDialectOptions): TiDBDialect;

package/dist/dialects/tidb/index.js

@@ -341,6 +341,16 @@ class TiDBDialect extends index_1.MySQLDialect {
     async removeConstraint(tableName, constraintName) {
         await this.query(this.buildDropConstraintSql(tableName, constraintName));
     }
+    /**
+     * TiDB implements no spatial/GIS data types, so a spatial index has nothing
+     * to index and a real server rejects it. Fail up front with a clear,
+     * actionable error (mirrors {@link getDataTypeSql}'s spatial-type rejection)
+     * instead of surfacing an opaque server-side parse error.
+     */
+    async createSpatialIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error('TiDB does not support spatial indexes (it has no spatial/GIS data types). ' +
+            'Store geometry as JSON/TEXT or numeric columns and index those instead.');
+    }
     /**
      * Build a TiDB `SPLIT TABLE` statement. This pre-splits a table's (or an
      * index's) key range into `regions` regions, distributing write load before