ts-prorm-orm 1.2.3 → 2.1.0

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 {};

package/dist/dialects/lock-clause-helper.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HANA_LOCK_SPEC = exports.DB2_LOCK_SPEC = exports.ORACLE_LOCK_SPEC = exports.MARIADB_LOCK_SPEC = exports.MYSQL_LOCK_SPEC = exports.COCKROACHDB_LOCK_SPEC = exports.POSTGRES_LOCK_SPEC = void 0;
+exports.normalizeLockOptions = normalizeLockOptions;
+exports.buildLockClause = buildLockClause;
+exports.appendLockClause = appendLockClause;
+exports.buildSqlServerLockHint = buildSqlServerLockHint;
+exports.getLockSpecForDialect = getLockSpecForDialect;
+const KNOWN_LEVELS = ['UPDATE', 'SHARE', 'KEY SHARE', 'NO KEY UPDATE'];
+function levelList(spec) {
+    return Object.keys(spec.levels).join(', ');
+}
+function parseLevel(value) {
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid lock level ${JSON.stringify(value)}. Expected one of: ${KNOWN_LEVELS.join(', ')}.`);
+    }
+    const normalized = value.trim().toUpperCase().replace(/\s+/g, ' ');
+    if (KNOWN_LEVELS.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unknown lock level ${JSON.stringify(value)}. Expected one of: ${KNOWN_LEVELS.join(', ')}.`);
+}
+/**
+ * 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.
+ */
+function normalizeLockOptions(lock) {
+    if (!lock) {
+        return undefined;
+    }
+    if (lock === true) {
+        return { level: 'UPDATE', nowait: false, skipLocked: false };
+    }
+    if (typeof lock === 'string') {
+        return { level: parseLevel(lock), nowait: false, skipLocked: false };
+    }
+    if (typeof lock !== 'object') {
+        throw new Error(`Invalid "lock" option: expected true, a lock level string, or an options object, got ${typeof lock}.`);
+    }
+    const raw = lock;
+    const rawLevel = raw.level ?? raw.mode;
+    const level = rawLevel === undefined || rawLevel === null ? 'UPDATE' : parseLevel(rawLevel);
+    const nowait = raw.nowait === true || raw.noWait === true;
+    const skipLocked = raw.skipLocked === true;
+    if (nowait && skipLocked) {
+        throw new Error('Invalid "lock" option: NOWAIT and SKIP LOCKED are mutually exclusive - set only one of lock.nowait / lock.skipLocked.');
+    }
+    return { level, nowait, skipLocked, of: raw.of };
+}
+/**
+ * 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`
+ */
+function buildLockClause(lock, spec, escapeId = (id) => id) {
+    const normalized = normalizeLockOptions(lock);
+    if (!normalized) {
+        return '';
+    }
+    const levelSql = spec.levels[normalized.level];
+    if (levelSql === undefined) {
+        throw new Error(`${spec.name} does not support ${normalized.level} row locking. Supported lock levels: ${levelList(spec)}.`);
+    }
+    let clause = typeof levelSql === 'function' ? levelSql(normalized) : levelSql;
+    if (normalized.of && spec.renderOf) {
+        const ofLevels = spec.ofLevels ?? Object.keys(spec.levels);
+        if (ofLevels.includes(normalized.level)) {
+            const ofSql = spec.renderOf(normalized.of, escapeId);
+            if (ofSql) {
+                clause += ` ${ofSql}`;
+            }
+        }
+    }
+    if (normalized.nowait) {
+        if (!spec.nowaitLevels?.includes(normalized.level)) {
+            throw new Error(`${spec.name} does not support NOWAIT with a ${normalized.level} lock. ` +
+                `Remove lock.nowait, or use a lock level that supports it${spec.nowaitLevels?.length ? ` (${spec.nowaitLevels.join(', ')})` : ''}.`);
+        }
+        clause += ' NOWAIT';
+    }
+    else if (normalized.skipLocked) {
+        if (!spec.skipLockedLevels?.includes(normalized.level)) {
+            throw new Error(`${spec.name} does not support SKIP LOCKED with a ${normalized.level} lock. ` +
+                `Remove lock.skipLocked, or use a lock level that supports it${spec.skipLockedLevels?.length ? ` (${spec.skipLockedLevels.join(', ')})` : ''}.`);
+        }
+        clause += ' SKIP LOCKED';
+    }
+    return clause;
+}
+/**
+ * Same as {@link buildLockClause} but returns the clause with a leading space
+ * (or `''`), which is how every `buildSelectQuery()` wants to append it.
+ */
+function appendLockClause(lock, spec, escapeId) {
+    const clause = buildLockClause(lock, spec, escapeId);
+    return clause ? ` ${clause}` : '';
+}
+/* -------------------------------------------------------------------------- */
+/* Per-dialect specs                                                          */
+/* -------------------------------------------------------------------------- */
+/**
+ * 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.
+ */
+exports.POSTGRES_LOCK_SPEC = {
+    name: 'PostgreSQL',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        'NO KEY UPDATE': 'FOR NO KEY UPDATE',
+        SHARE: 'FOR SHARE',
+        'KEY SHARE': 'FOR KEY SHARE',
+    },
+    nowaitLevels: KNOWN_LEVELS,
+    skipLockedLevels: KNOWN_LEVELS,
+    // Historically `OF` was emitted even for a model with no tableName (as `OF ""`);
+    // keep that byte-for-byte rather than silently dropping the requested scope.
+    renderOf: (model, escapeId) => `OF ${escapeId(model.tableName || '')}`,
+};
+/** CockroachDB implements the PostgreSQL locking grammar. */
+exports.COCKROACHDB_LOCK_SPEC = {
+    ...exports.POSTGRES_LOCK_SPEC,
+    name: 'CockroachDB',
+};
+/**
+ * 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`.
+ */
+exports.MYSQL_LOCK_SPEC = {
+    name: 'MySQL',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        SHARE: (lock) => (lock.nowait || lock.skipLocked ? 'FOR SHARE' : 'LOCK IN SHARE MODE'),
+    },
+    nowaitLevels: ['UPDATE', 'SHARE'],
+    skipLockedLevels: ['UPDATE', 'SHARE'],
+    renderOf: (model, escapeId) => (model.tableName ? `OF ${escapeId(model.tableName)}` : ''),
+    ofLevels: ['UPDATE'],
+};
+/**
+ * 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).
+ */
+exports.MARIADB_LOCK_SPEC = {
+    name: 'MariaDB',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        SHARE: (lock) => (lock.nowait || lock.skipLocked ? 'FOR SHARE' : 'LOCK IN SHARE MODE'),
+    },
+    nowaitLevels: ['UPDATE', 'SHARE'],
+    skipLockedLevels: ['UPDATE', 'SHARE'],
+};
+/**
+ * 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.
+ */
+exports.ORACLE_LOCK_SPEC = {
+    name: 'Oracle',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+    },
+    nowaitLevels: ['UPDATE'],
+    skipLockedLevels: ['UPDATE'],
+};
+/**
+ * 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.
+ */
+exports.DB2_LOCK_SPEC = {
+    name: 'Db2',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+        SHARE: 'FOR UPDATE WITH RS',
+    },
+};
+/** SAP HANA: `FOR UPDATE [NOWAIT]`. No shared row lock and no `SKIP LOCKED`. */
+exports.HANA_LOCK_SPEC = {
+    name: 'SAP HANA',
+    levels: {
+        UPDATE: 'FOR UPDATE',
+    },
+    nowaitLevels: ['UPDATE'],
+};
+/* -------------------------------------------------------------------------- */
+/* SQL Server - table hints rather than a trailing clause                     */
+/* -------------------------------------------------------------------------- */
+const SQLSERVER_LEVEL_HINTS = {
+    UPDATE: 'UPDLOCK',
+    SHARE: 'HOLDLOCK',
+};
+/**
+ * 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).
+ */
+function buildSqlServerLockHint(lock, tableName) {
+    const normalized = normalizeLockOptions(lock);
+    if (!normalized) {
+        return '';
+    }
+    const levelHint = SQLSERVER_LEVEL_HINTS[normalized.level];
+    if (!levelHint) {
+        throw new Error(`SQL Server does not support ${normalized.level} row locking. Supported lock levels: UPDATE, SHARE.`);
+    }
+    if (normalized.of) {
+        const ofTable = normalized.of.tableName || normalized.of.name;
+        if (ofTable && tableName && ofTable !== tableName) {
+            throw new Error(`SQL Server cannot scope a lock to ${JSON.stringify(ofTable)} from a query on ${JSON.stringify(tableName)}: locking is expressed as a table hint, which only applies to the table it is attached to.`);
+        }
+    }
+    const hints = [levelHint, 'ROWLOCK'];
+    if (normalized.nowait) {
+        hints.push('NOWAIT');
+    }
+    else if (normalized.skipLocked) {
+        hints.push('READPAST');
+    }
+    return `WITH (${hints.join(', ')})`;
+}
+/* -------------------------------------------------------------------------- */
+/* Dialect-name lookup                                                        */
+/* -------------------------------------------------------------------------- */
+const SPECS_BY_DIALECT = {
+    postgres: exports.POSTGRES_LOCK_SPEC,
+    postgresql: exports.POSTGRES_LOCK_SPEC,
+    pg: exports.POSTGRES_LOCK_SPEC,
+    greenplum: exports.POSTGRES_LOCK_SPEC,
+    timescaledb: exports.POSTGRES_LOCK_SPEC,
+    yugabytedb: exports.POSTGRES_LOCK_SPEC,
+    vertica: exports.POSTGRES_LOCK_SPEC,
+    cockroachdb: exports.COCKROACHDB_LOCK_SPEC,
+    mysql: exports.MYSQL_LOCK_SPEC,
+    tidb: exports.MYSQL_LOCK_SPEC,
+    singlestore: exports.MYSQL_LOCK_SPEC,
+    mariadb: exports.MARIADB_LOCK_SPEC,
+    oracle: exports.ORACLE_LOCK_SPEC,
+    db2: exports.DB2_LOCK_SPEC,
+    hana: exports.HANA_LOCK_SPEC,
+};
+/**
+ * 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".
+ */
+function getLockSpecForDialect(dialect) {
+    if (typeof dialect !== 'string') {
+        return undefined;
+    }
+    return SPECS_BY_DIALECT[dialect.toLowerCase()];
+}

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

@@ -740,10 +740,13 @@ export declare class MariaDBDialect implements Dialect {
      */
     removeIndex(tableName: string, indexName: string): Promise<void>;
     /**
-     * Create a partial index (index with WHERE clause)
-     * MariaDB supports partial indexes since version 10.0.3
+     * Partial (filtered) indexes - not available on MariaDB.
+     *
+     * The claim that MariaDB 10.0.3 added them is wrong: `CREATE INDEX` has never
+     * taken a `WHERE` clause on MariaDB (a live mariadb:11 server answers
+     * ER_PARSE_ERROR), so this throws rather than build that statement.
      */
-    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    createPartialIndex(_tableName: string, _indexName: string, _fields: string[], _where: string, _options?: IndexOptions): Promise<void>;
     /**
      * Create an index on a table with full options support
      */
@@ -753,7 +756,7 @@ export declare class MariaDBDialect implements Dialect {
         type?: string;
         using?: string;
         fields: string[];
-        where?: WhereOptions;
+        where?: WhereOptions | string;
         invisible?: boolean;
     }): Promise<void>;
     /**