ts-prorm-orm 1.2.3 → 2.1.0

package/dist/query-builders/order-limit-builder.js

@@ -9,6 +9,8 @@ exports.createOrderBuilder = createOrderBuilder;
 exports.createOrderLimitBuilder = createOrderLimitBuilder;
 exports.buildOrder = buildOrder;
 exports.buildLimitOffset = buildLimitOffset;
+const operators_1 = require("../operators");
+const order_expression_helper_1 = require("../dialects/order-expression-helper");
 /**
  * OrderBuilder class for building ORDER BY clauses
  */
@@ -45,18 +47,18 @@ class OrderBuilder {
             return item;
         }
         // Handle OrderExpression from order helper functions (asc, desc, random)
-        if (item && typeof item === 'object' && item.__type === 'order') {
-            const direction = item.direction;
-            if (direction === 'RANDOM') {
-                // RANDOM() for SQLite/PostgreSQL, RAND() for MySQL/MariaDB
-                const dialectName = this.options.dialect?.name;
-                if (dialectName === 'mysql' || dialectName === 'mariadb') {
-                    return 'RAND()';
-                }
-                // Default to RANDOM() (SQLite/PostgreSQL)
+        if ((0, operators_1.isOrderExpression)(item)) {
+            const dialectName = this.options.dialect?.name;
+            if (!dialectName && item.direction === 'RANDOM') {
+                // Standalone builder with no dialect configured: there is nothing to
+                // look the random function up by, so keep the historical default
+                // rather than throwing.
                 return 'RANDOM()';
             }
-            return `${this.escapeId(item.field)} ${direction}`;
+            // Otherwise render through the same shared helper the dialects' own
+            // buildOrderClause() uses, so `order: [desc('name')]` / `random()`
+            // produce identical SQL whichever of the two paths a query takes.
+            return (0, order_expression_helper_1.renderOrderExpression)({ name: dialectName, escapeId: (id) => this.escapeId(id) }, item);
         }
         // Handle array: ['field', 'ASC'] or [['field', 'ASC'], ['field2', 'DESC']]
         if (Array.isArray(item)) {

package/dist/query-builders/sql-compiler.d.ts

@@ -468,11 +468,18 @@ export declare class SqlCompiler {
      */
     private compileFrameBound;
     /**
-     * Compile lock options for row-level locking
-     * Supports NOWAIT and SKIP LOCKED for PostgreSQL and MySQL 8.0+
+     * Compile lock options for row-level locking.
+     *
+     * Delegates to the shared dialect lock compiler so this and each dialect's
+     * own `buildSelectQuery()` can never disagree about what a given `lock` shape
+     * means. Supports `true`, a level string, and the
+     * `{ level, nowait, skipLocked, of }` object form; throws when the named
+     * dialect cannot express the requested lock.
+     *
      * @param lock - Lock options
      * @param dialect - The database dialect
-     * @returns The compiled lock SQL clause
+     * @returns The compiled lock SQL clause, or an empty string for no lock and
+     *   for dialects with no trailing locking clause (SQLite, SQL Server, ...)
      */
     compileLockOptions(lock: any, dialect?: string): string;
     /**

package/dist/query-builders/sql-compiler.js

@@ -15,6 +15,7 @@ exports.jsonKeys = jsonKeys;
 exports.jsonLength = jsonLength;
 exports.jsonContains = jsonContains;
 exports.jsonSearch = jsonSearch;
+const lock_clause_helper_1 = require("../dialects/lock-clause-helper");
 const operators_1 = require("../operators");
 /**
  * Default compiler options
@@ -1816,55 +1817,25 @@ class SqlCompiler {
         return bound === 1 ? '1 FOLLOWING' : `${bound} FOLLOWING`;
     }
     /**
-     * Compile lock options for row-level locking
-     * Supports NOWAIT and SKIP LOCKED for PostgreSQL and MySQL 8.0+
+     * Compile lock options for row-level locking.
+     *
+     * Delegates to the shared dialect lock compiler so this and each dialect's
+     * own `buildSelectQuery()` can never disagree about what a given `lock` shape
+     * means. Supports `true`, a level string, and the
+     * `{ level, nowait, skipLocked, of }` object form; throws when the named
+     * dialect cannot express the requested lock.
+     *
      * @param lock - Lock options
      * @param dialect - The database dialect
-     * @returns The compiled lock SQL clause
+     * @returns The compiled lock SQL clause, or an empty string for no lock and
+     *   for dialects with no trailing locking clause (SQLite, SQL Server, ...)
      */
     compileLockOptions(lock, dialect = 'postgres') {
-        if (!lock) {
+        const spec = (0, lock_clause_helper_1.getLockSpecForDialect)(dialect);
+        if (!spec) {
             return '';
         }
-        let lockType;
-        let nowait = false;
-        let skipLocked = false;
-        // Extract lock configuration
-        if (lock === true) {
-            lockType = 'UPDATE';
-        }
-        else if (typeof lock === 'string') {
-            lockType = lock;
-        }
-        else if (typeof lock === 'object') {
-            lockType = lock.level || lock;
-            nowait = lock.nowait === true;
-            skipLocked = lock.skipLocked === true;
-        }
-        // Build base lock clause
-        let lockClause = '';
-        if (lockType === 'UPDATE' || lockType === 'UPDATE') {
-            lockClause = 'FOR UPDATE';
-        }
-        else if (lockType === 'SHARE') {
-            if (dialect === 'mysql') {
-                lockClause = 'LOCK IN SHARE MODE';
-            }
-            else {
-                lockClause = 'FOR SHARE';
-            }
-        }
-        else if (lockType === 'KEY SHARE') {
-            lockClause = 'FOR KEY SHARE';
-        }
-        // Add NOWAIT or SKIP LOCKED (PostgreSQL and MySQL 8.0+)
-        if (nowait && (dialect === 'postgres' || dialect === 'mysql')) {
-            lockClause += ' NOWAIT';
-        }
-        else if (skipLocked && (dialect === 'postgres' || dialect === 'mysql')) {
-            lockClause += ' SKIP LOCKED';
-        }
-        return lockClause;
+        return (0, lock_clause_helper_1.buildLockClause)(lock, spec);
     }
     /**
      * Compile OVER clause with partition, order, and window frame

package/dist/query-interface.d.ts

@@ -57,7 +57,8 @@ export interface ConstraintDefinition {
     };
     onDelete?: string;
     onUpdate?: string;
-    where?: WhereOptions;
+    /** Partial-index predicate; see `IndexOptions.where` in `src/dialects/dialect.ts`. */
+    where?: WhereOptions | string;
 }
 /**
  * Bulk operation options

package/dist/schema-objects.d.ts

@@ -16,6 +16,9 @@ export type SqlDialectName = 'mysql' | 'mariadb' | 'postgres' | 'cockroachdb' |
 export declare class UnsupportedSchemaObjectError extends Error {
     constructor(object: string, dialect: string, hint?: string);
 }
+/**
+ * A named sequence: its start, increment, bounds and caching.
+ */
 export interface SequenceOptions {
     /** Value the sequence starts at (default 1) */
     start?: number;
@@ -32,8 +35,18 @@ export interface SequenceOptions {
     /** Emit IF NOT EXISTS where supported */
     ifNotExists?: boolean;
 }
+/**
+ * Builds `CREATE SEQUENCE` for the dialect.
+ */
 export declare function buildCreateSequenceSQL(name: string, options: SequenceOptions, dialect: SqlDialectName, quoteId: (id: string) => string): string;
+/**
+ * Builds `DROP SEQUENCE` for the dialect.
+ */
 export declare function buildDropSequenceSQL(name: string, dialect: SqlDialectName, quoteId: (id: string) => string, ifExists?: boolean): string;
+/**
+ * A row-level security policy: who it applies to, which command, and the
+ * expressions that decide visibility (`using`) and writability (`withCheck`).
+ */
 export interface PolicyOptions {
     /** Table the policy applies to */
     table: string;
@@ -48,9 +61,23 @@ export interface PolicyOptions {
     /** Roles the policy applies to */
     to?: string[];
 }
+/**
+ * Builds the statement that turns row-level security on for a table. Until
+ * this runs, policies are defined but not enforced.
+ */
 export declare function buildEnableRowLevelSecuritySQL(table: string, dialect: SqlDialectName, quoteTable: (t: string) => string, enable?: boolean): string;
+/**
+ * Builds `CREATE POLICY` for a row-level security rule.
+ */
 export declare function buildCreatePolicySQL(options: PolicyOptions, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string): string;
+/**
+ * Builds `DROP POLICY`.
+ */
 export declare function buildDropPolicySQL(name: string, table: string, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string, ifExists?: boolean): string;
+/**
+ * A full-text index: the columns it covers, the language configuration, and
+ * any per-column weighting the engine supports.
+ */
 export interface FullTextIndexOptions {
     /** Index name */
     name: string;
@@ -61,7 +88,14 @@ export interface FullTextIndexOptions {
     /** Text search configuration (PostgreSQL), e.g. 'english' */
     language?: string;
 }
+/**
+ * Builds the engine's full-text index statement — a GIN index over a tsvector
+ * on PostgreSQL, `FULLTEXT` on MySQL, an FTS5 virtual table on SQLite.
+ */
 export declare function buildCreateFullTextIndexSQL(options: FullTextIndexOptions, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string): string;
+/**
+ * A trigger: when it fires, on which events, and the body it runs.
+ */
 export interface TriggerDefinition {
     name: string;
     table: string;
@@ -74,5 +108,13 @@ export interface TriggerDefinition {
     /** Condition guarding the trigger */
     when?: string;
 }
+/**
+ * Builds the statements a trigger needs. Some engines want a separate
+ * function or procedure before the trigger itself, so this returns a list
+ * rather than one statement.
+ */
 export declare function buildCreateTriggerStatements(trigger: TriggerDefinition, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string): string[];
+/**
+ * Builds `DROP TRIGGER`.
+ */
 export declare function buildDropTriggerSQL(name: string, table: string, dialect: SqlDialectName, quoteId: (id: string) => string, quoteTable: (t: string) => string, ifExists?: boolean): string;

package/dist/schema-objects.js

@@ -54,6 +54,9 @@ class UnsupportedSchemaObjectError extends Error {
     }
 }
 exports.UnsupportedSchemaObjectError = UnsupportedSchemaObjectError;
+/**
+ * Builds `CREATE SEQUENCE` for the dialect.
+ */
 function buildCreateSequenceSQL(name, options, dialect, quoteId) {
     if (isSqliteFamily(dialect)) {
         throw new UnsupportedSchemaObjectError('CREATE SEQUENCE', dialect, 'SQLite has no sequences - use an INTEGER PRIMARY KEY AUTOINCREMENT column instead.');
@@ -83,6 +86,9 @@ function buildCreateSequenceSQL(name, options, dialect, quoteId) {
         parts.push('CYCLE');
     return parts.join(' ');
 }
+/**
+ * Builds `DROP SEQUENCE` for the dialect.
+ */
 function buildDropSequenceSQL(name, dialect, quoteId, ifExists = true) {
     if (isSqliteFamily(dialect) || dialect === 'mysql') {
         throw new UnsupportedSchemaObjectError('DROP SEQUENCE', dialect);
@@ -91,6 +97,10 @@ function buildDropSequenceSQL(name, dialect, quoteId, ifExists = true) {
     const guard = ifExists && dialect !== 'oracle' ? 'IF EXISTS ' : '';
     return `DROP SEQUENCE ${guard}${quoteId(name)}`;
 }
+/**
+ * Builds the statement that turns row-level security on for a table. Until
+ * this runs, policies are defined but not enforced.
+ */
 function buildEnableRowLevelSecuritySQL(table, dialect, quoteTable, enable = true) {
     if (!isPostgresFamily(dialect)) {
         throw new UnsupportedSchemaObjectError('Row-level security', dialect, dialect === 'mssql'
@@ -99,6 +109,9 @@ function buildEnableRowLevelSecuritySQL(table, dialect, quoteTable, enable = tru
     }
     return `ALTER TABLE ${quoteTable(table)} ${enable ? 'ENABLE' : 'DISABLE'} ROW LEVEL SECURITY`;
 }
+/**
+ * Builds `CREATE POLICY` for a row-level security rule.
+ */
 function buildCreatePolicySQL(options, dialect, quoteId, quoteTable) {
     if (!isPostgresFamily(dialect)) {
         throw new UnsupportedSchemaObjectError('CREATE POLICY', dialect);
@@ -114,12 +127,19 @@ function buildCreatePolicySQL(options, dialect, quoteId, quoteTable) {
         sql += ` WITH CHECK (${options.withCheck})`;
     return sql;
 }
+/**
+ * Builds `DROP POLICY`.
+ */
 function buildDropPolicySQL(name, table, dialect, quoteId, quoteTable, ifExists = true) {
     if (!isPostgresFamily(dialect)) {
         throw new UnsupportedSchemaObjectError('DROP POLICY', dialect);
     }
     return `DROP POLICY ${ifExists ? 'IF EXISTS ' : ''}${quoteId(name)} ON ${quoteTable(table)}`;
 }
+/**
+ * Builds the engine's full-text index statement — a GIN index over a tsvector
+ * on PostgreSQL, `FULLTEXT` on MySQL, an FTS5 virtual table on SQLite.
+ */
 function buildCreateFullTextIndexSQL(options, dialect, quoteId, quoteTable) {
     const { name, table, columns, language = 'english' } = options;
     if (!columns.length) {
@@ -145,6 +165,11 @@ function buildCreateFullTextIndexSQL(options, dialect, quoteId, quoteTable) {
     }
     throw new UnsupportedSchemaObjectError('Full-text index', dialect);
 }
+/**
+ * Builds the statements a trigger needs. Some engines want a separate
+ * function or procedure before the trigger itself, so this returns a list
+ * rather than one statement.
+ */
 function buildCreateTriggerStatements(trigger, dialect, quoteId, quoteTable) {
     const { name, table, timing, event, body, forEach = 'ROW', when } = trigger;
     if (isPostgresFamily(dialect)) {
@@ -188,6 +213,9 @@ function buildCreateTriggerStatements(trigger, dialect, quoteId, quoteTable) {
     }
     throw new UnsupportedSchemaObjectError('CREATE TRIGGER', dialect);
 }
+/**
+ * Builds `DROP TRIGGER`.
+ */
 function buildDropTriggerSQL(name, table, dialect, quoteId, quoteTable, ifExists = true) {
     const guard = ifExists ? 'IF EXISTS ' : '';
     if (isMysqlFamily(dialect) || isSqliteFamily(dialect)) {

package/dist/sql-constants.d.ts

@@ -113,6 +113,14 @@ export interface PostgresConstants {
     SEARCH_PATH: SearchPath;
     AUTOCOMMIT: Autocommit;
     CACHE: Cache;
+    /**
+     * Optional: PostgreSQL has no `SET FOREIGN_KEY_CHECKS`. The session-level
+     * equivalent is `session_replication_role`, which is present on true
+     * PostgreSQL and CockroachDB but absent from some PostgreSQL-derived engines
+     * (Redshift does not enforce foreign keys at all), so this is deliberately
+     * optional rather than a required member with a fake value.
+     */
+    FOREIGN_KEY_CHECKS?: ForeignKeyChecks;
 }
 /**
  * SQLite SQL constants
@@ -193,6 +201,10 @@ export declare const COCKROACHDB: CockroachDBConstants;
  * Amazon Redshift SQL constants
  * Redshift is derived from PostgreSQL 8.0.2 and only supports the
  * SERIALIZABLE (default) and READ COMMITTED isolation levels.
+ *
+ * No FOREIGN_KEY_CHECKS: Redshift treats foreign keys as informational only -
+ * it never enforces them and has no `session_replication_role` - so there is
+ * nothing to turn off.
  */
 export declare const REDSHIFT: RedshiftConstants;
 /**
@@ -225,6 +237,38 @@ export declare const SQL: SQLConstants;
  * 'cockroachdb', 'redshift', 'db2', 'snowflake', 'clickhouse')
  */
 export declare function getConstantsForDialect(dialect: string): MySQLConstants | PostgresConstants | SQLiteConstants | DB2Constants | SnowflakeConstants | ClickHouseConstants;
+/** Which end of the switch is wanted. */
+export type ForeignKeyChecksMode = 'disable' | 'enable';
+/**
+ * Raised when a dialect has no session-level foreign key switch.
+ *
+ * Mirrors `UnsupportedSchemaObjectError` in ./schema-objects: name the database
+ * and say what to do instead, rather than returning SQL that fails at the
+ * server. Declared here (not imported) to keep this module dependency-free.
+ */
+export declare class UnsupportedForeignKeyChecksError extends Error {
+    constructor(dialect: string, hint?: string);
+}
+/**
+ * SQL that turns foreign key enforcement off/on for the current session.
+ *
+ * Every family has its own statement and they are not interchangeable:
+ * SQLite/Turso use a PRAGMA, the MySQL family a session variable, and the
+ * PostgreSQL family `session_replication_role`. Handing MySQL's
+ * `SET FOREIGN_KEY_CHECKS` to anything else - which is what the default branch
+ * used to do for every unlisted dialect, PostgreSQL included - produces a
+ * syntax error at the server, and the caller only finds out at runtime.
+ *
+ * The PostgreSQL form needs superuser, or a role granted
+ * `SET ON PARAMETER session_replication_role` (PostgreSQL 15+); on an ordinary
+ * application role the server answers `permission denied to set parameter`.
+ *
+ * @throws {UnsupportedForeignKeyChecksError} when the dialect has no
+ * session-level equivalent (SQL Server, Oracle and Db2 are per-table or
+ * per-constraint; Redshift, Snowflake, ClickHouse and friends do not enforce
+ * foreign keys at all).
+ */
+export declare function getForeignKeyChecksSQL(dialect: string, mode: ForeignKeyChecksMode): string;
 /**
  * Transaction isolation level enum
  */

package/dist/sql-constants.js

@@ -5,8 +5,9 @@
  * like foreign key checks, transaction isolation levels, etc.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsolationLevelEnum = exports.SQL = exports.CLICKHOUSE = exports.SNOWFLAKE = exports.DB2 = exports.REDSHIFT = exports.COCKROACHDB = exports.SQLITE = exports.POSTGRES = exports.MARIADB = exports.MYSQL = void 0;
+exports.IsolationLevelEnum = exports.UnsupportedForeignKeyChecksError = exports.SQL = exports.CLICKHOUSE = exports.SNOWFLAKE = exports.DB2 = exports.REDSHIFT = exports.COCKROACHDB = exports.SQLITE = exports.POSTGRES = exports.MARIADB = exports.MYSQL = void 0;
 exports.getConstantsForDialect = getConstantsForDialect;
+exports.getForeignKeyChecksSQL = getForeignKeyChecksSQL;
 /**
  * MySQL/MariaDB SQL constants
  */
@@ -87,6 +88,22 @@ exports.POSTGRES = {
         on: 'SET SESSION statement_cache_mode = ON',
         off: 'SET SESSION statement_cache_mode = OFF',
     },
+    /**
+     * PostgreSQL suppresses foreign key (and trigger) enforcement for the session
+     * by pretending to be a replication target. There is no `SET
+     * FOREIGN_KEY_CHECKS` - that is MySQL syntax and PostgreSQL rejects it with a
+     * syntax error.
+     *
+     * Requires superuser, or (PostgreSQL 15+) a role that has been granted
+     * `SET ON PARAMETER session_replication_role`. On a plain application role
+     * the server raises `permission denied to set parameter`; that error is left
+     * to surface rather than being swallowed, because silently continuing with
+     * foreign keys still enforced is the failure mode this replaced.
+     */
+    FOREIGN_KEY_CHECKS: {
+        disable: "SET session_replication_role = 'replica'",
+        enable: "SET session_replication_role = 'origin'",
+    },
 };
 /**
  * SQLite SQL constants
@@ -150,11 +167,21 @@ exports.COCKROACHDB = {
         on: 'SET SESSION statement_cache_mode = ON',
         off: 'SET SESSION statement_cache_mode = OFF',
     },
+    /** CockroachDB implements `session_replication_role` (v22.2+) with the same
+     * `replica`/`origin` values as PostgreSQL. */
+    FOREIGN_KEY_CHECKS: {
+        disable: "SET session_replication_role = 'replica'",
+        enable: "SET session_replication_role = 'origin'",
+    },
 };
 /**
  * Amazon Redshift SQL constants
  * Redshift is derived from PostgreSQL 8.0.2 and only supports the
  * SERIALIZABLE (default) and READ COMMITTED isolation levels.
+ *
+ * No FOREIGN_KEY_CHECKS: Redshift treats foreign keys as informational only -
+ * it never enforces them and has no `session_replication_role` - so there is
+ * nothing to turn off.
  */
 exports.REDSHIFT = {
     ISOLATION_LEVEL: {
@@ -284,10 +311,120 @@ function getConstantsForDialect(dialect) {
             return exports.SNOWFLAKE;
         case 'clickhouse':
             return exports.CLICKHOUSE;
+        // Derived dialects report their own name but run the parent server's
+        // session SQL. Without these, `getConstantsForDialect('timescaledb')` fell
+        // through to the MySQL constants and handed MySQL syntax to a PostgreSQL
+        // server.
+        case 'timescaledb':
+        case 'greenplum':
+        case 'yugabytedb':
+            return exports.POSTGRES;
+        case 'turso':
+            return exports.SQLITE;
+        case 'tidb':
+            return exports.MYSQL;
         default:
             return exports.MYSQL;
     }
 }
+// ==================== Foreign key checks ====================
+/**
+ * Dialects whose session-level foreign key switch is SQLite's PRAGMA.
+ * Turso/libSQL is SQLite over the wire and shares the pragma verbatim.
+ */
+const SQLITE_FK_DIALECTS = new Set(['sqlite', 'turso']);
+/**
+ * Dialects that implement MySQL's `SET FOREIGN_KEY_CHECKS` session variable.
+ *
+ * TiDB implements the variable for MySQL compatibility. SingleStore and
+ * Databricks extend the MySQL dialect class in this codebase but do not support
+ * enforced foreign keys at all, so they are deliberately absent - an explicit
+ * error naming the database beats a statement the server rejects.
+ */
+const MYSQL_FK_DIALECTS = new Set(['mysql', 'mariadb', 'tidb']);
+/**
+ * Dialects that implement PostgreSQL's `session_replication_role`.
+ *
+ * TimescaleDB and Greenplum are PostgreSQL servers; YugabyteDB and CockroachDB
+ * reimplement the parameter with the same `replica`/`origin` values. Trino,
+ * CrateDB, QuestDB, Exasol, Vertica and Redshift extend the Postgres dialect
+ * class here but are separate engines with no such parameter (Redshift never
+ * enforces foreign keys in the first place), so they are left out.
+ */
+const POSTGRES_FK_DIALECTS = new Set([
+    'postgres',
+    'timescaledb',
+    'greenplum',
+    'yugabytedb',
+    'cockroachdb',
+]);
+/**
+ * Why a given dialect cannot switch foreign key enforcement for a whole
+ * session, and what to do instead. Used to build the thrown error message.
+ */
+const FK_CHECKS_UNSUPPORTED_HINTS = {
+    mssql: 'Use ALTER TABLE <table> NOCHECK CONSTRAINT ALL per table instead.',
+    oracle: 'Use ALTER TABLE <table> DISABLE CONSTRAINT <name> per constraint instead.',
+    db2: 'Use SET INTEGRITY FOR <table> OFF / IMMEDIATE CHECKED per table instead.',
+    redshift: 'Redshift treats foreign keys as informational only and never enforces them.',
+    snowflake: 'Snowflake does not enforce foreign keys, so there is nothing to disable.',
+    clickhouse: 'ClickHouse has no foreign key constraints.',
+    duckdb: 'DuckDB has no session-level switch; drop and recreate the constraint instead.',
+    singlestore: 'SingleStore does not support enforced foreign key constraints.',
+    databricks: 'Databricks foreign keys are informational only and are never enforced.',
+    spanner: 'Spanner has no session-level switch; drop and recreate the constraint instead.',
+};
+/**
+ * Raised when a dialect has no session-level foreign key switch.
+ *
+ * Mirrors `UnsupportedSchemaObjectError` in ./schema-objects: name the database
+ * and say what to do instead, rather than returning SQL that fails at the
+ * server. Declared here (not imported) to keep this module dependency-free.
+ */
+class UnsupportedForeignKeyChecksError extends Error {
+    constructor(dialect, hint) {
+        super(`Session-level foreign key checks are not supported on ${dialect}` +
+            `${hint ? `. ${hint}` : ''}`);
+        this.name = 'UnsupportedForeignKeyChecksError';
+    }
+}
+exports.UnsupportedForeignKeyChecksError = UnsupportedForeignKeyChecksError;
+/**
+ * SQL that turns foreign key enforcement off/on for the current session.
+ *
+ * Every family has its own statement and they are not interchangeable:
+ * SQLite/Turso use a PRAGMA, the MySQL family a session variable, and the
+ * PostgreSQL family `session_replication_role`. Handing MySQL's
+ * `SET FOREIGN_KEY_CHECKS` to anything else - which is what the default branch
+ * used to do for every unlisted dialect, PostgreSQL included - produces a
+ * syntax error at the server, and the caller only finds out at runtime.
+ *
+ * The PostgreSQL form needs superuser, or a role granted
+ * `SET ON PARAMETER session_replication_role` (PostgreSQL 15+); on an ordinary
+ * application role the server answers `permission denied to set parameter`.
+ *
+ * @throws {UnsupportedForeignKeyChecksError} when the dialect has no
+ * session-level equivalent (SQL Server, Oracle and Db2 are per-table or
+ * per-constraint; Redshift, Snowflake, ClickHouse and friends do not enforce
+ * foreign keys at all).
+ */
+function getForeignKeyChecksSQL(dialect, mode) {
+    if (SQLITE_FK_DIALECTS.has(dialect)) {
+        return mode === 'disable' ? exports.SQLITE.PRAGMA.foreign_keys.off : exports.SQLITE.PRAGMA.foreign_keys.on;
+    }
+    if (MYSQL_FK_DIALECTS.has(dialect)) {
+        return exports.MYSQL.FOREIGN_KEY_CHECKS[mode];
+    }
+    if (POSTGRES_FK_DIALECTS.has(dialect)) {
+        // COCKROACHDB carries its own copy of the constant; both resolve to the
+        // same `session_replication_role` statement.
+        const constants = dialect === 'cockroachdb' ? exports.COCKROACHDB : exports.POSTGRES;
+        const checks = constants.FOREIGN_KEY_CHECKS;
+        if (checks)
+            return checks[mode];
+    }
+    throw new UnsupportedForeignKeyChecksError(dialect, FK_CHECKS_UNSUPPORTED_HINTS[dialect]);
+}
 /**
  * Transaction isolation level enum
  */