ts-prorm-orm 1.2.2 → 2.0.0

package/dist/dialects/clickhouse/index.js

@@ -40,6 +40,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClickHouseDialect = void 0;
 exports.createClickHouseDialect = createClickHouseDialect;
+const partial_index_1 = require("../partial-index");
 // Lazily-loaded `@clickhouse/client` module. The native/runtime driver is only
 // required the first time a connection is opened, so merely importing this ORM
 // never pulls in the ClickHouse driver.
@@ -59,6 +60,7 @@ function loadClickHouse() {
 }
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 /**
  * ClickHouse dialect class that implements the Dialect interface.
  *
@@ -950,6 +952,12 @@ class ClickHouseDialect {
         if (options?.ifNotExists)
             sql += ' IF NOT EXISTS';
         sql += ` ${this.escapeId(indexName)} ${expr} TYPE ${type} GRANULARITY ${granularity}`;
+        // ClickHouse indexes are data-skipping indexes on the whole part set; there
+        // is no predicate to restrict them. `where` was accepted and dropped on the
+        // floor here, so the caller silently got an unfiltered index.
+        if (options?.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
+        }
         await this.query(sql);
     }
     async removeIndex(tableName, indexName) {
@@ -959,6 +967,7 @@ class ClickHouseDialect {
         await this.addIndex(tableName, indexDef.name, indexDef.fields, {
             type: indexDef.type,
             using: indexDef.using,
+            where: indexDef.where,
         });
     }
     async dropIndex(tableName, indexName, options) {
@@ -1359,6 +1368,12 @@ class ClickHouseDialect {
             return '';
         const parts = [];
         const processItem = (item) => {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                parts.push(orderExpr);
+                return;
+            }
             if (typeof item === 'string') {
                 const [field, dir] = item.split(' ');
                 parts.push(dir ? `${this.escapeId(field)} ${dir.toUpperCase()}` : this.escapeId(field));

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

@@ -1013,7 +1013,7 @@ export declare class CockroachDBDialect implements Dialect {
         type?: string;
         using?: string;
         fields: string[];
-        where?: WhereOptions;
+        where?: WhereOptions | string;
         expression?: string;
         include?: string[];
         concurrently?: boolean;

package/dist/dialects/cockroachdb/index.js

@@ -36,7 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CockroachDBTransaction = exports.CockroachDBDialect = void 0;
 exports.createCockroachDBDialect = createCockroachDBDialect;
 const operators_1 = require("../../operators");
+const lock_clause_helper_1 = require("../lock-clause-helper");
+const partial_index_1 = require("../partial-index");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 // Lazily-loaded `pg` driver. Required only when a connection is opened, so
 // importing this ORM never loads the pg driver.
 let pgModule = null;
@@ -2327,9 +2330,14 @@ class CockroachDBDialect {
         if (options?.include && options.include.length > 0) {
             sql += ` INCLUDE (${options.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
+        // Partial index predicate. The ordinary WHERE builder emits `$1`-style
+        // placeholders and this DDL is executed without a value list, so the
+        // predicate is compiled with its values inlined as escaped literals.
         if (options?.where) {
-            const whereClause = this.buildWhereClause(options.where);
-            sql += ` WHERE ${whereClause.sql}`;
+            const predicate = (0, partial_index_1.buildPartialIndexPredicate)(options.where, this.name, this);
+            if (predicate) {
+                sql += ` WHERE ${predicate}`;
+            }
         }
         await this.query(sql);
     }
@@ -2385,9 +2393,12 @@ class CockroachDBDialect {
         if (indexDef.include && indexDef.include.length > 0) {
             sql += ` INCLUDE (${indexDef.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
-        if (indexDef.where && Object.keys(indexDef.where).length > 0) {
-            const whereClause = this.buildWhereClause(indexDef.where);
-            sql += ` WHERE ${whereClause.sql}`;
+        // Partial index predicate - inlined literals, not placeholders. See addIndex.
+        if (indexDef.where) {
+            const predicate = (0, partial_index_1.buildPartialIndexPredicate)(indexDef.where, this.name, this);
+            if (predicate) {
+                sql += ` WHERE ${predicate}`;
+            }
         }
         await this.query(sql);
     }
@@ -3252,12 +3263,18 @@ class CockroachDBDialect {
      * Build an ORDER BY clause
      */
     buildOrderClause(order, options) {
-        const orderArray = order;
-        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+        const orderArray = (0, order_expression_helper_1.normalizeOrderItems)(order);
+        if (orderArray.length === 0) {
             return '';
         }
         const orderParts = [];
         for (const item of orderArray) {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                continue;
+            }
             if (Array.isArray(item)) {
                 const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
                 const direction = item[1] ? ` ${item[1]}` : '';
@@ -3977,35 +3994,10 @@ class CockroachDBDialect {
         }
         // Build LIMIT/OFFSET clause
         sql += this.buildLimitOffset(options.limit, options.offset);
-        // Handle row-level locking (CockroachDB specific)
-        if (options.lock) {
-            let lockType;
-            // lock: true is equivalent to 'UPDATE'
-            if (options.lock === true) {
-                lockType = 'UPDATE';
-            }
-            else if (typeof options.lock === 'string') {
-                lockType = options.lock;
-            }
-            else if (typeof options.lock === 'object' && options.lock.of) {
-                // lock: { of: Model } - defaults to FOR UPDATE for table-specific locking
-                lockType = 'UPDATE';
-            }
-            if (lockType === 'UPDATE') {
-                sql += ' FOR UPDATE';
-            }
-            else if (lockType === 'SHARE') {
-                sql += ' FOR SHARE';
-            }
-            else if (lockType === 'KEY SHARE') {
-                sql += ' FOR KEY SHARE';
-            }
-            // Handle lock on specific table (CockroachDB supports OF clause)
-            if (typeof options.lock === 'object' && options.lock.of) {
-                const model = options.lock.of;
-                sql += ` OF ${this.escapeId(model.tableName || '')}`;
-            }
-        }
+        // Handle row-level locking. CockroachDB implements the PostgreSQL locking
+        // grammar; the shared helper compiles every documented `lock` shape so the
+        // object forms can't silently produce an unlocked SELECT.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.COCKROACHDB_LOCK_SPEC, (id) => this.escapeId(id));
         // Build UNION clause if provided
         if (options.union && options.union.length > 0) {
             const unionType = options.unionType || 'UNION';
@@ -4156,33 +4148,10 @@ class CockroachDBDialect {
      * Get CockroachDB specific lock options
      */
     getLockOptions(lock) {
-        const params = [];
-        let sql = '';
-        const lockType = typeof lock === 'string' ? lock : lock?.level;
-        switch (lockType) {
-            case 'UPDATE':
-                sql = 'FOR UPDATE';
-                break;
-            case 'SHARE':
-                sql = 'FOR SHARE';
-                break;
-            case 'KEY SHARE':
-                sql = 'FOR KEY SHARE';
-                break;
-            default:
-                return { sql: '', params };
-        }
-        if (typeof lock === 'object' && lock?.of) {
-            const model = lock.of;
-            sql += ` OF ${this.escapeId(model.tableName || '')}`;
-        }
-        if (typeof lock === 'object' && lock?.nowait) {
-            sql += ' NOWAIT';
-        }
-        else if (typeof lock === 'object' && lock?.skipLocked) {
-            sql += ' SKIP LOCKED';
-        }
-        return { sql, params };
+        return {
+            sql: (0, lock_clause_helper_1.buildLockClause)(lock, lock_clause_helper_1.COCKROACHDB_LOCK_SPEC, (id) => this.escapeId(id)),
+            params: [],
+        };
     }
     // ---------------------------------------------------------------------------
     // User / Privilege management — CockroachDB dialect

package/dist/dialects/db2/index.js

@@ -14,6 +14,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB2Dialect = void 0;
+const partial_index_1 = require("../partial-index");
 // Lazily-loaded `ibm_db` driver. This native (ODBC-based) addon is only loaded
 // the first time a connection is opened, so importing this ORM never dlopens
 // the ibm_db native binding.
@@ -32,7 +33,9 @@ function loadIbmDb() {
     return ibmDbModule;
 }
 const query_stream_helper_1 = require("../query-stream-helper");
+const lock_clause_helper_1 = require("../lock-clause-helper");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 /**
  * Db2-specific transaction class.
  * Db2 transactions (via ibm_db) are tied to a specific connection - the
@@ -1031,6 +1034,13 @@ class DB2Dialect {
         if (options?.include && options.include.length > 0) {
             sql += ` INCLUDE (${options.include.map((f) => this.escapeId(f)).join(', ')})`;
         }
+        // Db2 has no partial/filtered index predicate (only `EXCLUDE NULL KEYS` on
+        // a unique index, which is not a general WHERE). `where` used to be
+        // accepted by createIndex and then silently dropped here, so the caller got
+        // a full index without being told; say so instead.
+        if (options?.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
+        }
         return sql;
     }
     async addIndex(tableName, indexName, fields, options) {
@@ -1671,12 +1681,18 @@ class DB2Dialect {
         return { sql, values };
     }
     buildOrderClause(order, _options) {
-        const orderArray = order;
-        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+        const orderArray = (0, order_expression_helper_1.normalizeOrderItems)(order);
+        if (orderArray.length === 0) {
             return '';
         }
         const orderParts = [];
         for (const item of orderArray) {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                continue;
+            }
             if (Array.isArray(item)) {
                 const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
                 const direction = item[1] ? ` ${item[1]}` : '';
@@ -1902,12 +1918,11 @@ class DB2Dialect {
         if (options.limit !== undefined || options.offset !== undefined) {
             sql += this.buildLimitOffset(options.limit, options.offset);
         }
-        if (options.lock) {
-            sql += ' FOR UPDATE';
-            if (options.lock === 'SHARE') {
-                sql += ' WITH RS';
-            }
-        }
+        // Row-level locking: `FOR UPDATE`, with the read-stability isolation clause
+        // for a shared lock. Db2 has no `NOWAIT` and spells lock-avoidance as
+        // `SKIP LOCKED DATA` inside an isolation clause, so both modifiers throw
+        // rather than being silently dropped.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.DB2_LOCK_SPEC);
         return { sql, values };
     }
     /**

package/dist/dialects/dialect.d.ts

@@ -627,8 +627,18 @@ export interface TableOptions {
     rowFormat?: string;
     indexes?: TableIndex[];
     constraints?: TableConstraint[];
-    /** Unique keys to create with the table */
-    uniqueKeys?: Record<string, string[]>;
+    /**
+     * Unique keys to create with the table.
+     *
+     * Both shapes are accepted because both have always been passed: the legacy
+     * `{ name: fields[] }` map, and the `UniqueKeyOptions`-style array that
+     * `ModelOptions.uniqueKeys` is declared as. The dialects already branch on
+     * `Array.isArray`; the type now says so.
+     */
+    uniqueKeys?: Record<string, string[]> | Array<{
+        name?: string;
+        fields: string[];
+    }>;
     /** PostgreSQL tablespace */
     tablespace?: string;
     /** PostgreSQL: inherit from parent table */
@@ -663,7 +673,8 @@ export interface TableIndex {
     type?: string;
     using?: string;
     fields: string[];
-    where?: WhereOptions;
+    /** See {@link IndexOptions.where}. */
+    where?: WhereOptions | string;
     /** Expression for expression-based indexes (e.g., LOWER(column)) */
     expression?: string;
     /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
@@ -700,7 +711,19 @@ export interface IndexOptions {
     unique?: boolean;
     type?: string;
     using?: string;
-    where?: WhereOptions;
+    /**
+     * Partial (filtered) index predicate.
+     *
+     * Compiled into the `CREATE INDEX ... WHERE ...` clause with every value
+     * inlined as an escaped literal, because DDL is executed without a parameter
+     * list - see `src/dialects/partial-index.ts`. A string is taken as a
+     * predicate the caller already wrote and passed through unchanged.
+     *
+     * Only databases with real partial indexes accept this (PostgreSQL family,
+     * SQLite/Turso, SQL Server filtered indexes); the rest throw an
+     * `UnsupportedSchemaObjectError` rather than emit SQL the server rejects.
+     */
+    where?: WhereOptions | string;
     /** Expression for expression-based indexes (e.g., LOWER(column)) */
     expression?: string;
     /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
@@ -727,7 +750,8 @@ export interface IndexDefinition {
     type?: string;
     using?: string;
     fields: string[];
-    where?: WhereOptions;
+    /** See {@link IndexOptions.where}. */
+    where?: WhereOptions | string;
     /** See {@link IndexOptions.invisible}. */
     invisible?: boolean;
 }

package/dist/dialects/duckdb/index.js

@@ -36,6 +36,7 @@ function loadDuckDb() {
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
 const operators_1 = require("../../operators");
+const order_expression_helper_1 = require("../order-expression-helper");
 function promisifyAll(target, sql, params) {
     return new Promise((resolve, reject) => {
         const cb = (err, rows) => {
@@ -1437,12 +1438,18 @@ class DuckDBDialect {
         return { sql: result.sql, values };
     }
     buildOrderClause(order) {
-        const orderArray = order;
-        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+        const orderArray = (0, order_expression_helper_1.normalizeOrderItems)(order);
+        if (orderArray.length === 0) {
             return '';
         }
         const orderParts = [];
         for (const item of orderArray) {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                continue;
+            }
             if (Array.isArray(item)) {
                 const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
                 const direction = item[1] ? ` ${item[1]}` : '';

package/dist/dialects/hana/index.js

@@ -48,6 +48,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HanaDialect = void 0;
+const partial_index_1 = require("../partial-index");
 // Lazily-loaded `hdb` driver. Required only when a connection is opened, so
 // importing this ORM never loads the hdb driver.
 let hdbModule = null;
@@ -65,7 +66,9 @@ function loadHdb() {
     return hdbModule;
 }
 const query_stream_helper_1 = require("../query-stream-helper");
+const lock_clause_helper_1 = require("../lock-clause-helper");
 const prorm_1 = require("../../prorm");
+const order_expression_helper_1 = require("../order-expression-helper");
 /** HANA requires a LIMIT whenever OFFSET is used; this sentinel stands in for "no limit". */
 const HANA_MAX_LIMIT = 2147483647;
 /**
@@ -829,6 +832,12 @@ class HanaDialect {
         if (options?.unique)
             sql += ' UNIQUE';
         sql += ` INDEX ${this.escapeId(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql})`;
+        // SAP HANA has no partial/filtered indexes (createPartialIndex already
+        // throws). `where` was silently dropped here, handing back a full index;
+        // fail the same way the dedicated method does.
+        if (options?.where) {
+            throw (0, partial_index_1.unsupportedPartialIndex)(this.name);
+        }
         return sql;
     }
     async addIndex(tableName, indexName, fields, options) {
@@ -842,6 +851,7 @@ class HanaDialect {
             unique: indexDef.unique,
             type: indexDef.type,
             using: indexDef.using,
+            where: indexDef.where,
         });
     }
     async dropIndex(tableName, indexName, _options) {
@@ -1183,12 +1193,18 @@ class HanaDialect {
         return { sql, values };
     }
     buildOrderClause(order, _options) {
-        const orderArray = order;
-        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+        const orderArray = (0, order_expression_helper_1.normalizeOrderItems)(order);
+        if (orderArray.length === 0) {
             return '';
         }
         const orderParts = [];
         for (const item of orderArray) {
+            // Order helpers: asc('name') / desc('name') / random()
+            const orderExpr = (0, order_expression_helper_1.renderOrderExpressionItem)(this, item);
+            if (orderExpr !== null) {
+                orderParts.push(orderExpr);
+                continue;
+            }
             if (Array.isArray(item)) {
                 const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
                 const direction = item[1] ? ` ${item[1]}` : '';
@@ -1386,9 +1402,10 @@ class HanaDialect {
         if (options.limit !== undefined || options.offset !== undefined) {
             sql += this.buildLimitOffset(options.limit, options.offset);
         }
-        if (options.lock) {
-            sql += ' FOR UPDATE';
-        }
+        // Row-level locking: HANA supports `FOR UPDATE [NOWAIT]` only - no shared
+        // row lock and no SKIP LOCKED, both of which now throw instead of silently
+        // degrading to a plain exclusive lock.
+        sql += (0, lock_clause_helper_1.appendLockClause)(options.lock, lock_clause_helper_1.HANA_LOCK_SPEC);
         return { sql, values };
     }
     /**

package/dist/dialects/lock-clause-helper.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Shared compiler for `FindOptions.lock` (row-level locking).
+ *
+ * Every dialect used to re-implement the `lock` option inline inside its own
+ * `buildSelectQuery()`, and every one of those copies understood a slightly
+ * different subset of the documented `LockOptions` shapes. The object forms
+ * (`{ level }`, `{ level, nowait }`, `{ level, skipLocked }`, `{ skipLocked }`)
+ * fell through most of them and compiled to *nothing* - the caller asked for a
+ * lock, got a plain `SELECT`, and only found out under concurrency. This module
+ * centralises the parsing (`normalizeLockOptions`) and the SQL assembly
+ * (`buildLockClause`) so a shape can only be dropped by deliberately leaving it
+ * out of a dialect's {@link LockClauseSpec} - and a spec that cannot express
+ * what was asked for throws instead of silently emitting a weaker lock.
+ *
+ * Dialects with no row-level locking at all (SQLite and friends) simply never
+ * call in here: ignoring `lock` is a deliberate, documented decision for them
+ * (SQLite serialises writers anyway), not an oversight.
+ *
+ * SQL Server is the odd one out - it expresses row locking as a table hint
+ * (`FROM t WITH (UPDLOCK, ROWLOCK)`) rather than a trailing clause - so it
+ * shares the parsing/validation via {@link buildSqlServerLockHint} while
+ * rendering its own syntax.
+ */
+/** The lock levels this ORM knows how to talk about, after normalization. */
+export type NormalizedLockLevel = 'UPDATE' | 'SHARE' | 'KEY SHARE' | 'NO KEY UPDATE';
+/** Model shape (`lock.of`) reduced to the only fields the SQL needs. */
+type LockOfModel = {
+    tableName?: string;
+    name?: string;
+};
+/** A `lock` option after every documented shape has been collapsed into one struct. */
+export interface NormalizedLock {
+    level: NormalizedLockLevel;
+    nowait: boolean;
+    skipLocked: boolean;
+    /** The model passed as `lock.of`, if any. Only some dialects can express it. */
+    of?: LockOfModel;
+}
+/**
+ * How one dialect renders row locks. A level that is absent from `levels` is
+ * one this dialect cannot express, and asking for it throws.
+ */
+export interface LockClauseSpec {
+    /** Human-readable dialect name, used in error messages. */
+    name: string;
+    /**
+     * SQL for each supported lock level. A function form lets a dialect pick its
+     * syntax based on the requested modifiers (MySQL/MariaDB switch between the
+     * legacy `LOCK IN SHARE MODE` and `FOR SHARE`, which is the only one of the
+     * two that accepts `NOWAIT`/`SKIP LOCKED`).
+     */
+    levels: Partial<Record<NormalizedLockLevel, string | ((lock: NormalizedLock) => string)>>;
+    /** Levels that accept `NOWAIT`. Omit entirely if the dialect has no `NOWAIT`. */
+    nowaitLevels?: NormalizedLockLevel[];
+    /** Levels that accept `SKIP LOCKED`. Omit entirely if the dialect has none. */
+    skipLockedLevels?: NormalizedLockLevel[];
+    /**
+     * Renders `lock.of`. Omitted when the dialect has no table-scoped locking, in
+     * which case `of` only signals that a lock was wanted at all (which is
+     * exactly how those dialects have always behaved).
+     */
+    renderOf?: (model: LockOfModel, escapeId: (id: string) => string) => string;
+    /** Levels for which `renderOf` applies. Defaults to every supported level. */
+    ofLevels?: NormalizedLockLevel[];
+}
+/**
+ * Collapse any documented `lock` shape into a {@link NormalizedLock}.
+ *
+ * Returns `undefined` for a falsy lock (`undefined`, `false`, `null`), which
+ * every caller treats as "no locking clause".
+ *
+ * Accepted shapes:
+ * - `true` -> `FOR UPDATE`
+ * - `'UPDATE' | 'SHARE' | 'KEY SHARE' | 'NO KEY UPDATE'` (case-insensitive)
+ * - `{ of: Model }` -> `FOR UPDATE` scoped to that table
+ * - `{ level?, nowait?, skipLocked?, of? }` -> level defaults to `UPDATE`
+ *
+ * `mode` is accepted as an alias for `level` and `noWait` for `nowait`, since
+ * the MariaDB dialect has always documented those spellings.
+ *
+ * Throws on a level it doesn't recognise rather than quietly emitting no lock.
+ */
+export declare function normalizeLockOptions(lock: unknown): NormalizedLock | undefined;
+/**
+ * Build the trailing locking clause for a dialect, e.g. `FOR UPDATE OF "users" NOWAIT`.
+ *
+ * Returns `''` when there is no lock to apply. Throws when the requested lock
+ * cannot be expressed by this dialect - a lock the caller believes they hold
+ * but don't is far worse than a loud failure at query-build time.
+ *
+ * @param lock - the raw `options.lock` value
+ * @param spec - the dialect's locking capabilities
+ * @param escapeId - the dialect's identifier quoter, used for `lock.of`
+ */
+export declare function buildLockClause(lock: unknown, spec: LockClauseSpec, escapeId?: (id: string) => string): string;
+/**
+ * Same as {@link buildLockClause} but returns the clause with a leading space
+ * (or `''`), which is how every `buildSelectQuery()` wants to append it.
+ */
+export declare function appendLockClause(lock: unknown, spec: LockClauseSpec, escapeId?: (id: string) => string): string;
+/**
+ * PostgreSQL: `FOR UPDATE | NO KEY UPDATE | SHARE | KEY SHARE [OF table] [NOWAIT | SKIP LOCKED]`.
+ * The full matrix - every level accepts both modifiers and the `OF` clause.
+ */
+export declare const POSTGRES_LOCK_SPEC: LockClauseSpec;
+/** CockroachDB implements the PostgreSQL locking grammar. */
+export declare const COCKROACHDB_LOCK_SPEC: LockClauseSpec;
+/**
+ * MySQL 8.0+: `FOR UPDATE [OF tbl] [NOWAIT | SKIP LOCKED]` and
+ * `FOR SHARE [OF tbl] [NOWAIT | SKIP LOCKED]`.
+ *
+ * A bare shared lock still compiles to the pre-8.0 `LOCK IN SHARE MODE`
+ * spelling (which every supported MySQL understands, and which existing
+ * `lock: 'SHARE'` callers already get); it only switches to the 8.0 `FOR SHARE`
+ * form when a modifier is requested, because `LOCK IN SHARE MODE` accepts
+ * neither `NOWAIT` nor `SKIP LOCKED`.
+ */
+export declare const MYSQL_LOCK_SPEC: LockClauseSpec;
+/**
+ * MariaDB: `FOR UPDATE` / `LOCK IN SHARE MODE` on every version, with
+ * `FOR SHARE` and the `SKIP LOCKED` / `NOWAIT` modifiers from 10.6.
+ *
+ * MariaDB has no `FOR UPDATE OF <table>`, so `lock.of` only signals that a lock
+ * was wanted (matching this dialect's long-standing behaviour).
+ */
+export declare const MARIADB_LOCK_SPEC: LockClauseSpec;
+/**
+ * Oracle: `FOR UPDATE [OF column] [NOWAIT | SKIP LOCKED]`.
+ *
+ * Oracle has no shared row lock (`SHARE`/`KEY SHARE` have no equivalent), and
+ * its `OF` names *columns*, not a table - a `lock.of` model can't be turned into
+ * one, so `of` is treated as a plain `FOR UPDATE` request exactly as it always
+ * has been.
+ */
+export declare const ORACLE_LOCK_SPEC: LockClauseSpec;
+/**
+ * Db2: `FOR UPDATE`, plus the `WITH RS` isolation clause for a read-stability
+ * (shared) lock. Db2 spells lock-avoidance as `SKIP LOCKED DATA` inside an
+ * isolation clause and has no `NOWAIT` at all, so both modifiers throw rather
+ * than being approximated.
+ */
+export declare const DB2_LOCK_SPEC: LockClauseSpec;
+/** SAP HANA: `FOR UPDATE [NOWAIT]`. No shared row lock and no `SKIP LOCKED`. */
+export declare const HANA_LOCK_SPEC: LockClauseSpec;
+/**
+ * Build the SQL Server locking table hint, e.g. `WITH (UPDLOCK, ROWLOCK)`.
+ *
+ * T-SQL has no `FOR UPDATE`; row locking is requested with hints on the table
+ * reference: `UPDLOCK`/`HOLDLOCK` for the lock itself, `ROWLOCK` to pin the
+ * granularity to rows, `READPAST` for `SKIP LOCKED` and `NOWAIT` for `NOWAIT`.
+ *
+ * Returns `''` when there is no lock to apply.
+ *
+ * @param lock - the raw `options.lock` value
+ * @param tableName - the table the hint will be attached to, so a `lock.of`
+ *   naming some *other* table can be rejected instead of silently locking the
+ *   wrong one (a hint only applies to the table reference it sits on).
+ */
+export declare function buildSqlServerLockHint(lock: unknown, tableName?: string): string;
+/**
+ * Look up the locking spec for a dialect name. Returns `undefined` for a
+ * dialect with no row-level locking (SQLite and friends) and for SQL Server,
+ * whose locking is a table hint rather than a trailing clause - callers should
+ * treat `undefined` as "emit no trailing lock clause".
+ */
+export declare function getLockSpecForDialect(dialect: string): LockClauseSpec | undefined;
+export {};