drizzle-orm 0.28.7-d3fbe4a → 0.29.0-9091d23

package/{alias-cf8e03cd.mjs → alias-aa343af5.cjs}

@@ -1,3 +1,5 @@
+'use strict';
+
 const entityKind = Symbol.for('drizzle:entityKind');
 const hasOwnEntityKind = Symbol.for('drizzle:hasOwnEntityKind');
 function is(value, type) {
@@ -67,7 +69,72 @@ class Column {
     }
 }
 
+/** @internal */
+const TableName = Symbol.for('drizzle:Name');
+/** @internal */
+const Schema = Symbol.for('drizzle:Schema');
+/** @internal */
+const Columns = Symbol.for('drizzle:Columns');
+/** @internal */
+const OriginalName = Symbol.for('drizzle:OriginalName');
+/** @internal */
+const BaseName = Symbol.for('drizzle:BaseName');
+/** @internal */
+const IsAlias = Symbol.for('drizzle:IsAlias');
+/** @internal */
+const ExtraConfigBuilder = Symbol.for('drizzle:ExtraConfigBuilder');
+const IsDrizzleTable = Symbol.for('drizzle:IsDrizzleTable');
+class Table {
+    static [entityKind] = 'Table';
+    /** @internal */
+    static Symbol = {
+        Name: TableName,
+        Schema: Schema,
+        OriginalName: OriginalName,
+        Columns: Columns,
+        BaseName: BaseName,
+        IsAlias: IsAlias,
+        ExtraConfigBuilder: ExtraConfigBuilder,
+    };
+    /**
+     * @internal
+     * Can be changed if the table is aliased.
+     */
+    [TableName];
+    /**
+     * @internal
+     * Used to store the original name of the table, before any aliasing.
+     */
+    [OriginalName];
+    /** @internal */
+    [Schema];
+    /** @internal */
+    [Columns];
+    /**
+     *  @internal
+     * Used to store the table name before the transformation via the `tableCreator` functions.
+     */
+    [BaseName];
+    /** @internal */
+    [IsAlias] = false;
+    /** @internal */
+    [ExtraConfigBuilder] = undefined;
+    [IsDrizzleTable] = true;
+    constructor(name, schema, baseName) {
+        this[TableName] = this[OriginalName] = name;
+        this[Schema] = schema;
+        this[BaseName] = baseName;
+    }
+}
+function isTable(table) {
+    return typeof table === 'object' && table !== null && IsDrizzleTable in table;
+}
+function getTableName(table) {
+    return table[TableName];
+}
+
 const ViewBaseConfig = Symbol.for('drizzle:ViewBaseConfig');
+
 class View {
     static [entityKind] = 'View';
     /** @internal */
@@ -277,73 +344,6 @@ function iife(fn, ...args) {
     return fn(...args);
 }
 
-/** @internal */
-const TableName = Symbol.for('drizzle:Name');
-/** @internal */
-const Schema = Symbol.for('drizzle:Schema');
-/** @internal */
-const Columns = Symbol.for('drizzle:Columns');
-/** @internal */
-const OriginalName = Symbol.for('drizzle:OriginalName');
-/** @internal */
-const BaseName = Symbol.for('drizzle:BaseName');
-/** @internal */
-const IsAlias = Symbol.for('drizzle:IsAlias');
-/** @internal */
-const ExtraConfigBuilder = Symbol.for('drizzle:ExtraConfigBuilder');
-const IsDrizzleTable = Symbol.for('drizzle:IsDrizzleTable');
-class Table {
-    static [entityKind] = 'Table';
-    /** @internal */
-    static Symbol = {
-        Name: TableName,
-        Schema: Schema,
-        OriginalName: OriginalName,
-        Columns: Columns,
-        BaseName: BaseName,
-        IsAlias: IsAlias,
-        ExtraConfigBuilder: ExtraConfigBuilder,
-    };
-    /**
-     * @internal
-     * Can be changed if the table is aliased.
-     */
-    [TableName];
-    /**
-     * @internal
-     * Used to store the original name of the table, before any aliasing.
-     */
-    [OriginalName];
-    /** @internal */
-    [Schema];
-    /** @internal */
-    [Columns];
-    /**
-     *  @internal
-     * Used to store the table name before the transformation via the `tableCreator` functions.
-     */
-    [BaseName];
-    /** @internal */
-    [IsAlias] = false;
-    /** @internal */
-    [ExtraConfigBuilder] = undefined;
-    [IsDrizzleTable] = true;
-    constructor(name, schema, baseName) {
-        this[TableName] = this[OriginalName] = name;
-        this[Schema] = schema;
-        this[BaseName] = baseName;
-    }
-    getSQL() {
-        return new SQL([this]);
-    }
-}
-function isTable(table) {
-    return typeof table === 'object' && table !== null && IsDrizzleTable in table;
-}
-function getTableName(table) {
-    return table[TableName];
-}
-
 class QueryPromise {
     static [entityKind] = 'QueryPromise';
     [Symbol.toStringTag] = 'QueryPromise';
@@ -375,20 +375,96 @@ const tracer = {
 
 class DrizzleError extends Error {
     static [entityKind] = 'DrizzleError';
-    constructor(message) {
+    constructor({ message, cause }) {
         super(message);
         this.name = 'DrizzleError';
-    }
-    static wrap(error, message) {
-        return error instanceof Error // eslint-disable-line no-instanceof/no-instanceof
-            ? new DrizzleError(message ? `${message}: ${error.message}` : error.message)
-            : new DrizzleError(message ?? String(error));
+        this.cause = cause;
     }
 }
 class TransactionRollbackError extends DrizzleError {
     static [entityKind] = 'TransactionRollbackError';
     constructor() {
-        super('Rollback');
+        super({ message: 'Rollback' });
+    }
+}
+
+// To understand how to use `ColumnBuilder` and `AnyColumnBuilder`, see `Column` and `AnyColumn` documentation.
+class ColumnBuilder {
+    static [entityKind] = 'ColumnBuilder';
+    config;
+    constructor(name, dataType, columnType) {
+        this.config = {
+            name,
+            notNull: false,
+            default: undefined,
+            hasDefault: false,
+            primaryKey: false,
+            isUnique: false,
+            uniqueName: undefined,
+            uniqueType: undefined,
+            dataType,
+            columnType,
+        };
+    }
+    /**
+     * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+     *
+     * @example
+     * ```ts
+     * const users = pgTable('users', {
+     * 	id: integer('id').$type<UserId>().primaryKey(),
+     * 	details: json('details').$type<UserDetails>().notNull(),
+     * });
+     * ```
+     */
+    $type() {
+        return this;
+    }
+    /**
+     * Adds a `not null` clause to the column definition.
+     *
+     * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+     */
+    notNull() {
+        this.config.notNull = true;
+        return this;
+    }
+    /**
+     * Adds a `default <value>` clause to the column definition.
+     *
+     * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+     *
+     * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+     */
+    default(value) {
+        this.config.default = value;
+        this.config.hasDefault = true;
+        return this;
+    }
+    /**
+     * Adds a dynamic default value to the column.
+     * The function will be called when the row is inserted, and the returned value will be used as the column value.
+     *
+     * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+     */
+    $defaultFn(fn) {
+        this.config.defaultFn = fn;
+        this.config.hasDefault = true;
+        return this;
+    }
+    /**
+     * Alias for {@link $defaultFn}.
+     */
+    $default = this.$defaultFn;
+    /**
+     * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+     *
+     * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+     */
+    primaryKey() {
+        this.config.primaryKey = true;
+        this.config.notNull = true;
+        return this;
     }
 }
 
@@ -430,35 +506,6 @@ function pgTableCreator(customizeTableName) {
     };
 }
 
-class CheckBuilder {
-    name;
-    value;
-    static [entityKind] = 'PgCheckBuilder';
-    brand;
-    constructor(name, value) {
-        this.name = name;
-        this.value = value;
-    }
-    /** @internal */
-    build(table) {
-        return new Check(table, this);
-    }
-}
-class Check {
-    table;
-    static [entityKind] = 'PgCheck';
-    name;
-    value;
-    constructor(table, builder) {
-        this.table = table;
-        this.name = builder.name;
-        this.value = builder.value;
-    }
-}
-function check(name, value) {
-    return new CheckBuilder(name, value);
-}
-
 class ForeignKeyBuilder {
     static [entityKind] = 'PgForeignKeyBuilder';
     /** @internal */
@@ -469,8 +516,8 @@ class ForeignKeyBuilder {
     _onDelete = 'no action';
     constructor(config, actions) {
         this.reference = () => {
-            const { columns, foreignColumns } = config();
-            return { columns, foreignTable: foreignColumns[0].table, foreignColumns };
+            const { name, columns, foreignColumns } = config();
+            return { name, columns, foreignTable: foreignColumns[0].table, foreignColumns };
         };
         if (actions) {
             this._onUpdate = actions.onUpdate;
@@ -503,7 +550,7 @@ class ForeignKey {
         this.onDelete = builder._onDelete;
     }
     getName() {
-        const { columns, foreignColumns } = this.reference();
+        const { name, columns, foreignColumns } = this.reference();
         const columnNames = columns.map((column) => column.name);
         const foreignColumnNames = foreignColumns.map((column) => column.name);
         const chunks = [
@@ -512,13 +559,14 @@ class ForeignKey {
             foreignColumns[0].table[PgTable.Symbol.Name],
             ...foreignColumnNames,
         ];
-        return `${chunks.join('_')}_fk`;
+        return name ?? `${chunks.join('_')}_fk`;
     }
 }
 function foreignKey(config) {
     function mappedConfig() {
-        const { columns, foreignColumns } = config;
+        const { name, columns, foreignColumns } = config;
         return {
+            name,
             columns,
             foreignColumns,
         };
@@ -526,132 +574,30 @@ function foreignKey(config) {
     return new ForeignKeyBuilder(mappedConfig);
 }
 
-class IndexBuilderOn {
-    unique;
+function unique(name) {
+    return new UniqueOnConstraintBuilder(name);
+}
+function uniqueKeyName(table, columns) {
+    return `${table[PgTable.Symbol.Name]}_${columns.join('_')}_unique`;
+}
+class UniqueConstraintBuilder {
     name;
-    static [entityKind] = 'PgIndexBuilderOn';
-    constructor(unique, name) {
-        this.unique = unique;
+    static [entityKind] = 'PgUniqueConstraintBuilder';
+    /** @internal */
+    columns;
+    /** @internal */
+    nullsNotDistinctConfig = false;
+    constructor(columns, name) {
         this.name = name;
+        this.columns = columns;
     }
-    on(...columns) {
-        return new IndexBuilder(columns, this.unique, false, this.name);
+    nullsNotDistinct() {
+        this.nullsNotDistinctConfig = true;
+        return this;
     }
-    onOnly(...columns) {
-        return new IndexBuilder(columns, this.unique, true, this.name);
-    }
-}
-class IndexBuilder {
-    static [entityKind] = 'PgIndexBuilder';
-    /** @internal */
-    config;
-    constructor(columns, unique, only, name) {
-        this.config = {
-            name,
-            columns,
-            unique,
-            only,
-        };
-    }
-    concurrently() {
-        this.config.concurrently = true;
-        return this;
-    }
-    using(method) {
-        this.config.using = method;
-        return this;
-    }
-    asc() {
-        this.config.order = 'asc';
-        return this;
-    }
-    desc() {
-        this.config.order = 'desc';
-        return this;
-    }
-    nullsFirst() {
-        this.config.nulls = 'first';
-        return this;
-    }
-    nullsLast() {
-        this.config.nulls = 'last';
-        return this;
-    }
-    where(condition) {
-        this.config.where = condition;
-        return this;
-    }
-    /** @internal */
-    build(table) {
-        return new Index(this.config, table);
-    }
-}
-class Index {
-    static [entityKind] = 'PgIndex';
-    config;
-    constructor(config, table) {
-        this.config = { ...config, table };
-    }
-}
-function index(name) {
-    return new IndexBuilderOn(false, name);
-}
-function uniqueIndex(name) {
-    return new IndexBuilderOn(true, name);
-}
-
-function primaryKey(...columns) {
-    return new PrimaryKeyBuilder(columns);
-}
-class PrimaryKeyBuilder {
-    static [entityKind] = 'PgPrimaryKeyBuilder';
-    /** @internal */
-    columns;
-    constructor(columns) {
-        this.columns = columns;
-    }
-    /** @internal */
-    build(table) {
-        return new PrimaryKey(table, this.columns);
-    }
-}
-class PrimaryKey {
-    table;
-    static [entityKind] = 'PgPrimaryKey';
-    columns;
-    constructor(table, columns) {
-        this.table = table;
-        this.columns = columns;
-    }
-    getName() {
-        return `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
-    }
-}
-
-function unique(name) {
-    return new UniqueOnConstraintBuilder(name);
-}
-function uniqueKeyName(table, columns) {
-    return `${table[PgTable.Symbol.Name]}_${columns.join('_')}_unique`;
-}
-class UniqueConstraintBuilder {
-    name;
-    static [entityKind] = 'PgUniqueConstraintBuilder';
-    /** @internal */
-    columns;
-    /** @internal */
-    nullsNotDistinctConfig = false;
-    constructor(columns, name) {
-        this.name = name;
-        this.columns = columns;
-    }
-    nullsNotDistinct() {
-        this.nullsNotDistinctConfig = true;
-        return this;
-    }
-    /** @internal */
-    build(table) {
-        return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+    /** @internal */
+    build(table) {
+        return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
     }
 }
 class UniqueOnConstraintBuilder {
@@ -682,59 +628,6 @@ class UniqueConstraint {
     }
 }
 
-function getTableConfig(table) {
-    const columns = Object.values(table[Table.Symbol.Columns]);
-    const indexes = [];
-    const checks = [];
-    const primaryKeys = [];
-    const foreignKeys = Object.values(table[PgTable.Symbol.InlineForeignKeys]);
-    const uniqueConstraints = [];
-    const name = table[Table.Symbol.Name];
-    const schema = table[Table.Symbol.Schema];
-    const extraConfigBuilder = table[PgTable.Symbol.ExtraConfigBuilder];
-    if (extraConfigBuilder !== undefined) {
-        const extraConfig = extraConfigBuilder(table[Table.Symbol.Columns]);
-        for (const builder of Object.values(extraConfig)) {
-            if (is(builder, IndexBuilder)) {
-                indexes.push(builder.build(table));
-            }
-            else if (is(builder, CheckBuilder)) {
-                checks.push(builder.build(table));
-            }
-            else if (is(builder, UniqueConstraintBuilder)) {
-                uniqueConstraints.push(builder.build(table));
-            }
-            else if (is(builder, PrimaryKeyBuilder)) {
-                primaryKeys.push(builder.build(table));
-            }
-            else if (is(builder, ForeignKeyBuilder)) {
-                foreignKeys.push(builder.build(table));
-            }
-        }
-    }
-    return {
-        columns,
-        indexes,
-        foreignKeys,
-        checks,
-        primaryKeys,
-        uniqueConstraints,
-        name,
-        schema,
-    };
-}
-function getViewConfig(view) {
-    return {
-        ...view[ViewBaseConfig],
-        ...view[PgViewConfig],
-    };
-}
-function getMaterializedViewConfig(view) {
-    return {
-        ...view[ViewBaseConfig],
-        ...view[PgMaterializedViewConfig],
-    };
-}
 function parsePgArrayValue(arrayString, startFrom, inQuotes) {
     for (let i = startFrom; i < arrayString.length; i++) {
         const char = arrayString[i];
@@ -810,86 +703,6 @@ function makePgArray(array) {
     }).join(',')}}`;
 }
 
-// To understand how to use `ColumnBuilder` and `AnyColumnBuilder`, see `Column` and `AnyColumn` documentation.
-class ColumnBuilder {
-    static [entityKind] = 'ColumnBuilder';
-    config;
-    constructor(name, dataType, columnType) {
-        this.config = {
-            name,
-            notNull: false,
-            default: undefined,
-            hasDefault: false,
-            primaryKey: false,
-            isUnique: false,
-            uniqueName: undefined,
-            uniqueType: undefined,
-            dataType,
-            columnType,
-        };
-    }
-    /**
-     * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
-     *
-     * @example
-     * ```ts
-     * const users = pgTable('users', {
-     * 	id: integer('id').$type<UserId>().primaryKey(),
-     * 	details: json('details').$type<UserDetails>().notNull(),
-     * });
-     * ```
-     */
-    $type() {
-        return this;
-    }
-    /**
-     * Adds a `not null` clause to the column definition.
-     *
-     * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
-     */
-    notNull() {
-        this.config.notNull = true;
-        return this;
-    }
-    /**
-     * Adds a `default <value>` clause to the column definition.
-     *
-     * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
-     *
-     * If you need to set a dynamic default value, use {@link $defaultFn} instead.
-     */
-    default(value) {
-        this.config.default = value;
-        this.config.hasDefault = true;
-        return this;
-    }
-    /**
-     * Adds a dynamic default value to the column.
-     * The function will be called when the row is inserted, and the returned value will be used as the column value.
-     *
-     * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
-     */
-    $defaultFn(fn) {
-        this.config.defaultFn = fn;
-        this.config.hasDefault = true;
-        return this;
-    }
-    /**
-     * Alias for {@link $defaultFn}.
-     */
-    $default = this.$defaultFn;
-    /**
-     * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
-     *
-     * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
-     */
-    primaryKey() {
-        this.config.primaryKey = true;
-        this.config.notNull = true;
-        return this;
-    }
-}
-
 class PgColumnBuilder extends ColumnBuilder {
     foreignKeyConfigs = [];
     static [entityKind] = 'PgColumnBuilder';
@@ -937,7 +750,6 @@ class PgColumn extends Column {
         this.table = table;
     }
 }
-
 class PgArrayBuilder extends PgColumnBuilder {
     static [entityKind] = 'PgArrayBuilder';
     constructor(name, baseBuilder, size) {
@@ -1387,7 +1199,7 @@ class PgDialect {
         });
         return sql.join(chunks);
     }
-    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClauses, distinct, }) {
+    buildSelectQuery({ withList, fields, fieldsFlat, where, having, table, joins, orderBy, groupBy, limit, offset, lockingClause, distinct, }) {
         const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
         for (const f of fieldsList) {
             if (is(f.field, Column)
@@ -1475,23 +1287,21 @@ class PgDialect {
         }
         const limitSql = limit ? sql ` limit ${limit}` : undefined;
         const offsetSql = offset ? sql ` offset ${offset}` : undefined;
-        const lockingClausesSql = sql.empty();
-        if (lockingClauses) {
-            for (const { strength, config } of lockingClauses) {
-                const clauseSql = sql ` for ${sql.raw(strength)}`;
-                if (config.of) {
-                    clauseSql.append(sql ` of ${config.of}`);
-                }
-                if (config.noWait) {
-                    clauseSql.append(sql ` no wait`);
-                }
-                else if (config.skipLocked) {
-                    clauseSql.append(sql ` skip locked`);
-                }
-                lockingClausesSql.append(clauseSql);
+        const lockingClauseSql = sql.empty();
+        if (lockingClause) {
+            const clauseSql = sql ` for ${sql.raw(lockingClause.strength)}`;
+            if (lockingClause.config.of) {
+                clauseSql.append(sql ` of ${sql.join(Array.isArray(lockingClause.config.of) ? lockingClause.config.of : [lockingClause.config.of], sql `, `)}`);
+            }
+            if (lockingClause.config.noWait) {
+                clauseSql.append(sql ` no wait`);
+            }
+            else if (lockingClause.config.skipLocked) {
+                clauseSql.append(sql ` skip locked`);
             }
+            lockingClauseSql.append(clauseSql);
         }
-        return sql `${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
+        return sql `${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
     }
     buildInsertQuery({ table, values, onConflict, returning }) {
         const valuesSqlList = [];
@@ -2186,7 +1996,7 @@ class PgDialect {
             }
         }
         if (selection.length === 0) {
-            throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
+            throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
         }
         let result;
         where = and(joinOn, where);
@@ -2295,7 +2105,7 @@ class PgSelectBuilder {
      * Specify the table, subquery, or other target that you're
      * building a select query against.
      *
-     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM|Postgres from documentation}
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}
      */
     from(source) {
         const isPartialSelect = !!this.fields;
@@ -2316,7 +2126,7 @@ class PgSelectBuilder {
         else {
             fields = getTableColumns(source);
         }
-        return new PgSelect({
+        return new PgSelectBase({
             table: source,
             fields,
             isPartialSelect,
@@ -2327,7 +2137,7 @@ class PgSelectBuilder {
         });
     }
 }
-class PgSelectQueryBuilder extends TypedQueryBuilder {
+class PgSelectQueryBuilderBase extends TypedQueryBuilder {
     static [entityKind] = 'PgSelectQueryBuilder';
     _;
     config;
@@ -2461,7 +2271,7 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
      * used with GROUP BY and filters rows after they've been
      * grouped together and combined.
      *
-     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING|Postgres having clause documentation}
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-HAVING | Postgres having clause documentation}
      */
     having(having) {
         if (typeof having === 'function') {
@@ -2501,7 +2311,7 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
      * db.select().from(people).limit(10);
      * ```
      *
-     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT|Postgres LIMIT documentation}
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-LIMIT | Postgres LIMIT documentation}
      */
     limit(limit) {
         this.config.limit = limit;
@@ -2527,13 +2337,10 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
      * that controls how strictly it acquires exclusive access to
      * the rows being queried.
      *
-     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE|Postgres locking clause documentation}
+     * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE | PostgreSQL locking clause documentation}
      */
     for(strength, config = {}) {
-        if (!this.config.lockingClauses) {
-            this.config.lockingClauses = [];
-        }
-        this.config.lockingClauses.push({ strength, config });
+        this.config.lockingClause = { strength, config };
         return this;
     }
     /** @internal */
@@ -2547,8 +2354,15 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
     as(alias) {
         return new Proxy(new Subquery(this.getSQL(), this.config.fields, alias), new SelectionProxyHandler({ alias, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }));
     }
+    /** @internal */
+    getSelectedFields() {
+        return new Proxy(this.config.fields, new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: 'alias', sqlBehavior: 'error' }));
+    }
+    $dynamic() {
+        return this;
+    }
 }
-class PgSelect extends PgSelectQueryBuilder {
+class PgSelectBase extends PgSelectQueryBuilderBase {
     static [entityKind] = 'PgSelect';
     _prepare(name) {
         const { session, config, dialect, joinsNotNullableMap } = this;
@@ -2567,7 +2381,7 @@ class PgSelect extends PgSelectQueryBuilder {
      * the database to remember this query for the given session
      * and call it by name, rather than specifying the full query.
      *
-     * {@link https://www.postgresql.org/docs/current/sql-prepare.html|Postgres prepare documentation}
+     * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
      */
     prepare(name) {
         return this._prepare(name);
@@ -2578,7 +2392,7 @@ class PgSelect extends PgSelectQueryBuilder {
         });
     };
 }
-applyMixins(PgSelect, [QueryPromise]);
+applyMixins(PgSelectBase, [QueryPromise]);
 
 class QueryBuilder {
     static [entityKind] = 'PgQueryBuilder';
@@ -2654,6 +2468,8 @@ class QueryBuilder {
     }
 }
 
+const PgViewConfig = Symbol.for('drizzle:PgViewConfig');
+
 class DefaultViewBuilderCore {
     name;
     schema;
@@ -2830,7 +2646,6 @@ class ManualMaterializedViewBuilder extends MaterializedViewBuilderCore {
 class PgViewBase extends View {
     static [entityKind] = 'PgViewBase';
 }
-const PgViewConfig = Symbol.for('drizzle:PgViewConfig');
 class PgView extends PgViewBase {
     static [entityKind] = 'PgView';
     [PgViewConfig];
@@ -2878,6 +2693,42 @@ function pgMaterializedView(name, columns) {
     return pgMaterializedViewWithSchema(name, columns, undefined);
 }
 
+function primaryKey(...config) {
+    if (config[0].columns) {
+        return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+    }
+    return new PrimaryKeyBuilder(config);
+}
+class PrimaryKeyBuilder {
+    static [entityKind] = 'PgPrimaryKeyBuilder';
+    /** @internal */
+    columns;
+    /** @internal */
+    name;
+    constructor(columns, name) {
+        this.columns = columns;
+        this.name = name;
+    }
+    /** @internal */
+    build(table) {
+        return new PrimaryKey(table, this.columns, this.name);
+    }
+}
+class PrimaryKey {
+    table;
+    static [entityKind] = 'PgPrimaryKey';
+    columns;
+    name;
+    constructor(table, columns, name) {
+        this.table = table;
+        this.columns = columns;
+        this.name = name;
+    }
+    getName() {
+        return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+    }
+}
+
 class Relation {
     sourceTable;
     referencedTable;
@@ -3125,43 +2976,445 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
     return result;
 }
 
-function bindIfParam(value, column) {
-    if (isDriverValueEncoder(column)
-        && !isSQLWrapper(value)
-        && !is(value, Param)
-        && !is(value, Placeholder)
-        && !is(value, Column)
-        && !is(value, Table)
-        && !is(value, View)) {
-        return new Param(value, column);
-    }
-    return value;
-}
 /**
- * Test that two values are equal.
- *
- * Remember that the SQL standard dictates that
- * two NULL values are not equal, so if you want to test
- * whether a value is null, you may want to use
- * `isNull` instead.
- *
- * ## Examples
- *
- * ```ts
- * // Select cars made by Ford
- * db.select().from(cars)
- *   .where(eq(cars.make, 'Ford'))
- * ```
- *
- * @see isNull for a way to test equality to NULL.
+ * This class is used to indicate a primitive param value that is used in `sql` tag.
+ * It is only used on type level and is never instantiated at runtime.
+ * If you see a value of this type in the code, its runtime value is actually the primitive param value.
  */
-const eq = (left, right) => {
-    return sql `${left} = ${bindIfParam(right, left)}`;
-};
-/**
- * Test that two values are not equal.
- *
- * Remember that the SQL standard dictates that
+class FakePrimitiveParam {
+    static [entityKind] = 'FakePrimitiveParam';
+}
+function isSQLWrapper(value) {
+    return typeof value === 'object' && value !== null && 'getSQL' in value
+        && typeof value.getSQL === 'function';
+}
+function mergeQueries(queries) {
+    const result = { sql: '', params: [] };
+    for (const query of queries) {
+        result.sql += query.sql;
+        result.params.push(...query.params);
+        if (query.typings?.length) {
+            if (!result.typings) {
+                result.typings = [];
+            }
+            result.typings.push(...query.typings);
+        }
+    }
+    return result;
+}
+class StringChunk {
+    static [entityKind] = 'StringChunk';
+    value;
+    constructor(value) {
+        this.value = Array.isArray(value) ? value : [value];
+    }
+    getSQL() {
+        return new SQL([this]);
+    }
+}
+class SQL {
+    queryChunks;
+    static [entityKind] = 'SQL';
+    /** @internal */
+    decoder = noopDecoder;
+    shouldInlineParams = false;
+    constructor(queryChunks) {
+        this.queryChunks = queryChunks;
+    }
+    append(query) {
+        this.queryChunks.push(...query.queryChunks);
+        return this;
+    }
+    toQuery(config) {
+        return tracer.startActiveSpan('drizzle.buildSQL', (span) => {
+            const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+            span?.setAttributes({
+                'drizzle.query.text': query.sql,
+                'drizzle.query.params': JSON.stringify(query.params),
+            });
+            return query;
+        });
+    }
+    buildQueryFromSourceParams(chunks, _config) {
+        const config = Object.assign({}, _config, {
+            inlineParams: _config.inlineParams || this.shouldInlineParams,
+            paramStartIndex: _config.paramStartIndex || { value: 0 },
+        });
+        const { escapeName, escapeParam, prepareTyping, inlineParams, paramStartIndex, } = config;
+        return mergeQueries(chunks.map((chunk) => {
+            if (is(chunk, StringChunk)) {
+                return { sql: chunk.value.join(''), params: [] };
+            }
+            if (is(chunk, Name)) {
+                return { sql: escapeName(chunk.value), params: [] };
+            }
+            if (chunk === undefined) {
+                return { sql: '', params: [] };
+            }
+            if (Array.isArray(chunk)) {
+                const result = [new StringChunk('(')];
+                for (const [i, p] of chunk.entries()) {
+                    result.push(p);
+                    if (i < chunk.length - 1) {
+                        result.push(new StringChunk(', '));
+                    }
+                }
+                result.push(new StringChunk(')'));
+                return this.buildQueryFromSourceParams(result, config);
+            }
+            if (is(chunk, SQL)) {
+                return this.buildQueryFromSourceParams(chunk.queryChunks, {
+                    ...config,
+                    inlineParams: inlineParams || chunk.shouldInlineParams,
+                });
+            }
+            if (is(chunk, Table)) {
+                const schemaName = chunk[Table.Symbol.Schema];
+                const tableName = chunk[Table.Symbol.Name];
+                return {
+                    sql: schemaName === undefined
+                        ? escapeName(tableName)
+                        : escapeName(schemaName) + '.' + escapeName(tableName),
+                    params: [],
+                };
+            }
+            if (is(chunk, Column)) {
+                return { sql: escapeName(chunk.table[Table.Symbol.Name]) + '.' + escapeName(chunk.name), params: [] };
+            }
+            if (is(chunk, View)) {
+                const schemaName = chunk[ViewBaseConfig].schema;
+                const viewName = chunk[ViewBaseConfig].name;
+                return {
+                    sql: schemaName === undefined
+                        ? escapeName(viewName)
+                        : escapeName(schemaName) + '.' + escapeName(viewName),
+                    params: [],
+                };
+            }
+            if (is(chunk, Param)) {
+                const mappedValue = (chunk.value === null) ? null : chunk.encoder.mapToDriverValue(chunk.value);
+                if (is(mappedValue, SQL)) {
+                    return this.buildQueryFromSourceParams([mappedValue], config);
+                }
+                if (inlineParams) {
+                    return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+                }
+                let typings;
+                if (prepareTyping !== undefined) {
+                    typings = [prepareTyping(chunk.encoder)];
+                }
+                return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+            }
+            if (is(chunk, Placeholder)) {
+                return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
+            }
+            if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+                return { sql: escapeName(chunk.fieldAlias), params: [] };
+            }
+            if (is(chunk, Subquery)) {
+                if (chunk[SubqueryConfig].isWith) {
+                    return { sql: escapeName(chunk[SubqueryConfig].alias), params: [] };
+                }
+                return this.buildQueryFromSourceParams([
+                    new StringChunk('('),
+                    chunk[SubqueryConfig].sql,
+                    new StringChunk(') '),
+                    new Name(chunk[SubqueryConfig].alias),
+                ], config);
+            }
+            // if (is(chunk, Placeholder)) {
+            // 	return {sql: escapeParam}
+            if (isSQLWrapper(chunk)) {
+                return this.buildQueryFromSourceParams([
+                    new StringChunk('('),
+                    chunk.getSQL(),
+                    new StringChunk(')'),
+                ], config);
+            }
+            if (is(chunk, Relation)) {
+                return this.buildQueryFromSourceParams([
+                    chunk.sourceTable,
+                    new StringChunk('.'),
+                    sql.identifier(chunk.fieldName),
+                ], config);
+            }
+            if (inlineParams) {
+                return { sql: this.mapInlineParam(chunk, config), params: [] };
+            }
+            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
+        }));
+    }
+    mapInlineParam(chunk, { escapeString }) {
+        if (chunk === null) {
+            return 'null';
+        }
+        if (typeof chunk === 'number' || typeof chunk === 'boolean') {
+            return chunk.toString();
+        }
+        if (typeof chunk === 'string') {
+            return escapeString(chunk);
+        }
+        if (typeof chunk === 'object') {
+            const mappedValueAsString = chunk.toString();
+            if (mappedValueAsString === '[object Object]') {
+                return escapeString(JSON.stringify(chunk));
+            }
+            return escapeString(mappedValueAsString);
+        }
+        throw new Error('Unexpected param value: ' + chunk);
+    }
+    getSQL() {
+        return this;
+    }
+    as(alias) {
+        // TODO: remove with deprecated overloads
+        if (alias === undefined) {
+            return this;
+        }
+        return new SQL.Aliased(this, alias);
+    }
+    mapWith(decoder) {
+        this.decoder = typeof decoder === 'function' ? { mapFromDriverValue: decoder } : decoder;
+        return this;
+    }
+    inlineParams() {
+        this.shouldInlineParams = true;
+        return this;
+    }
+}
+/**
+ * Any DB name (table, column, index etc.)
+ */
+class Name {
+    value;
+    static [entityKind] = 'Name';
+    brand;
+    constructor(value) {
+        this.value = value;
+    }
+    getSQL() {
+        return new SQL([this]);
+    }
+}
+/**
+ * Any DB name (table, column, index etc.)
+ * @deprecated Use `sql.identifier` instead.
+ */
+function name(value) {
+    return new Name(value);
+}
+function isDriverValueEncoder(value) {
+    return typeof value === 'object' && value !== null && 'mapToDriverValue' in value
+        && typeof value.mapToDriverValue === 'function';
+}
+const noopDecoder = {
+    mapFromDriverValue: (value) => value,
+};
+const noopEncoder = {
+    mapToDriverValue: (value) => value,
+};
+const noopMapper = {
+    ...noopDecoder,
+    ...noopEncoder,
+};
+/** Parameter value that is optionally bound to an encoder (for example, a column). */
+class Param {
+    value;
+    encoder;
+    static [entityKind] = 'Param';
+    brand;
+    /**
+     * @param value - Parameter value
+     * @param encoder - Encoder to convert the value to a driver parameter
+     */
+    constructor(value, encoder = noopEncoder) {
+        this.value = value;
+        this.encoder = encoder;
+    }
+    getSQL() {
+        return new SQL([this]);
+    }
+}
+/** @deprecated Use `sql.param` instead. */
+function param(value, encoder) {
+    return new Param(value, encoder);
+}
+/*
+    The type of `params` is specified as `SQLSourceParam[]`, but that's slightly incorrect -
+    in runtime, users won't pass `FakePrimitiveParam` instances as `params` - they will pass primitive values
+    which will be wrapped in `Param` using `buildChunksFromParam(...)`. That's why the overload
+    specify `params` as `any[]` and not as `SQLSourceParam[]`. This type is used to make our lives easier and
+    the type checker happy.
+*/
+function sql(strings, ...params) {
+    const queryChunks = [];
+    if (params.length > 0 || (strings.length > 0 && strings[0] !== '')) {
+        queryChunks.push(new StringChunk(strings[0]));
+    }
+    for (const [paramIndex, param] of params.entries()) {
+        queryChunks.push(param, new StringChunk(strings[paramIndex + 1]));
+    }
+    return new SQL(queryChunks);
+}
+(function (sql) {
+    function empty() {
+        return new SQL([]);
+    }
+    sql.empty = empty;
+    /** @deprecated - use `sql.join()` */
+    function fromList(list) {
+        return new SQL(list);
+    }
+    sql.fromList = fromList;
+    /**
+     * Convenience function to create an SQL query from a raw string.
+     * @param str The raw SQL query string.
+     */
+    function raw(str) {
+        return new SQL([new StringChunk(str)]);
+    }
+    sql.raw = raw;
+    /**
+     * Join a list of SQL chunks with a separator.
+     * @example
+     * ```ts
+     * const query = sql.join([sql`a`, sql`b`, sql`c`]);
+     * // sql`abc`
+     * ```
+     * @example
+     * ```ts
+     * const query = sql.join([sql`a`, sql`b`, sql`c`], sql`, `);
+     * // sql`a, b, c`
+     * ```
+     */
+    function join(chunks, separator) {
+        const result = [];
+        for (const [i, chunk] of chunks.entries()) {
+            if (i > 0 && separator !== undefined) {
+                result.push(separator);
+            }
+            result.push(chunk);
+        }
+        return new SQL(result);
+    }
+    sql.join = join;
+    /**
+     * Create a SQL chunk that represents a DB identifier (table, column, index etc.).
+     * When used in a query, the identifier will be escaped based on the DB engine.
+     * For example, in PostgreSQL, identifiers are escaped with double quotes.
+     *
+     * **WARNING: This function does not offer any protection against SQL injections, so you must validate any user input beforehand.**
+     *
+     * @example ```ts
+     * const query = sql`SELECT * FROM ${sql.identifier('my-table')}`;
+     * // 'SELECT * FROM "my-table"'
+     * ```
+     */
+    function identifier(value) {
+        return new Name(value);
+    }
+    sql.identifier = identifier;
+    function placeholder(name) {
+        return new Placeholder(name);
+    }
+    sql.placeholder = placeholder;
+    function param(value, encoder) {
+        return new Param(value, encoder);
+    }
+    sql.param = param;
+})(sql || (sql = {}));
+(function (SQL) {
+    class Aliased {
+        sql;
+        fieldAlias;
+        static [entityKind] = 'SQL.Aliased';
+        /** @internal */
+        isSelectionField = false;
+        constructor(sql, fieldAlias) {
+            this.sql = sql;
+            this.fieldAlias = fieldAlias;
+        }
+        getSQL() {
+            return this.sql;
+        }
+        /** @internal */
+        clone() {
+            return new Aliased(this.sql, this.fieldAlias);
+        }
+    }
+    SQL.Aliased = Aliased;
+})(SQL || (SQL = {}));
+class Placeholder {
+    name;
+    static [entityKind] = 'Placeholder';
+    constructor(name) {
+        this.name = name;
+    }
+    getSQL() {
+        return new SQL([this]);
+    }
+}
+/** @deprecated Use `sql.placeholder` instead. */
+function placeholder(name) {
+    return new Placeholder(name);
+}
+function fillPlaceholders(params, values) {
+    return params.map((p) => {
+        if (is(p, Placeholder)) {
+            if (!(p.name in values)) {
+                throw new Error(`No value for placeholder "${p.name}" was provided`);
+            }
+            return values[p.name];
+        }
+        return p;
+    });
+}
+// Defined separately from the Column class to resolve circular dependency
+Column.prototype.getSQL = function () {
+    return new SQL([this]);
+};
+// Defined separately from the Table class to resolve circular dependency
+Table.prototype.getSQL = function () {
+    return new SQL([this]);
+};
+
+function bindIfParam(value, column) {
+    if (isDriverValueEncoder(column)
+        && !isSQLWrapper(value)
+        && !is(value, Param)
+        && !is(value, Placeholder)
+        && !is(value, Column)
+        && !is(value, Table)
+        && !is(value, View)) {
+        return new Param(value, column);
+    }
+    return value;
+}
+/**
+ * Test that two values are equal.
+ *
+ * Remember that the SQL standard dictates that
+ * two NULL values are not equal, so if you want to test
+ * whether a value is null, you may want to use
+ * `isNull` instead.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made by Ford
+ * db.select().from(cars)
+ *   .where(eq(cars.make, 'Ford'))
+ * ```
+ *
+ * @see isNull for a way to test equality to NULL.
+ */
+const eq = (left, right) => {
+    return sql `${left} = ${bindIfParam(right, left)}`;
+};
+/**
+ * Test that two values are not equal.
+ *
+ * Remember that the SQL standard dictates that
  * two NULL values are not equal, so if you want to test
  * whether a value is not null, you may want to use
  * `isNotNull` instead.
@@ -3414,544 +3667,146 @@ function notBetween(column, min, max) {
  *   .where(like(cars.name, '%Turbo%'))
  * ```
  *
- * @see ilike for a case-insensitive version of this condition
- */
-function like(column, value) {
-    return sql `${column} like ${value}`;
-}
-/**
- * The inverse of like - this tests that a given column
- * does not match a pattern, which can include `%` and `_`
- * characters to match multiple variations. Including `%`
- * in the pattern matches zero or more characters, and including
- * `_` will match a single character.
- *
- * ## Examples
- *
- * ```ts
- * // Select all cars that don't have "ROver" in their name.
- * db.select().from(cars)
- *   .where(notLike(cars.name, '%Rover%'))
- * ```
- *
- * @see like for the inverse condition
- * @see notIlike for a case-insensitive version of this condition
- */
-function notLike(column, value) {
-    return sql `${column} not like ${value}`;
-}
-/**
- * Case-insensitively compare a column to a pattern,
- * which can include `%` and `_`
- * characters to match multiple variations. Including `%`
- * in the pattern matches zero or more characters, and including
- * `_` will match a single character.
- *
- * Unlike like, this performs a case-insensitive comparison.
- *
- * ## Examples
- *
- * ```ts
- * // Select all cars with 'Turbo' in their names.
- * db.select().from(cars)
- *   .where(ilike(cars.name, '%Turbo%'))
- * ```
- *
- * @see like for a case-sensitive version of this condition
- */
-function ilike(column, value) {
-    return sql `${column} ilike ${value}`;
-}
-/**
- * The inverse of ilike - this case-insensitively tests that a given column
- * does not match a pattern, which can include `%` and `_`
- * characters to match multiple variations. Including `%`
- * in the pattern matches zero or more characters, and including
- * `_` will match a single character.
- *
- * ## Examples
- *
- * ```ts
- * // Select all cars that don't have "Rover" in their name.
- * db.select().from(cars)
- *   .where(notLike(cars.name, '%Rover%'))
- * ```
- *
- * @see ilike for the inverse condition
- * @see notLike for a case-sensitive version of this condition
- */
-function notIlike(column, value) {
-    return sql `${column} not ilike ${value}`;
-}
-function arrayContains(column, values) {
-    if (Array.isArray(values)) {
-        if (values.length === 0) {
-            throw new Error('arrayContains requires at least one value');
-        }
-        const array = sql `${bindIfParam(values, column)}`;
-        return sql `${column} @> ${array}`;
-    }
-    return sql `${column} @> ${bindIfParam(values, column)}`;
-}
-function arrayContained(column, values) {
-    if (Array.isArray(values)) {
-        if (values.length === 0) {
-            throw new Error('arrayContained requires at least one value');
-        }
-        const array = sql `${bindIfParam(values, column)}`;
-        return sql `${column} <@ ${array}`;
-    }
-    return sql `${column} <@ ${bindIfParam(values, column)}`;
-}
-function arrayOverlaps(column, values) {
-    if (Array.isArray(values)) {
-        if (values.length === 0) {
-            throw new Error('arrayOverlaps requires at least one value');
-        }
-        const array = sql `${bindIfParam(values, column)}`;
-        return sql `${column} && ${array}`;
-    }
-    return sql `${column} && ${bindIfParam(values, column)}`;
-}
-
-/**
- * Used in sorting, this specifies that the given
- * column or expression should be sorted in ascending
- * order. By the SQL standard, ascending order is the
- * default, so it is not usually necessary to specify
- * ascending sort order.
- *
- * ## Examples
- *
- * ```ts
- * // Return cars, starting with the oldest models
- * // and going in ascending order to the newest.
- * db.select().from(cars)
- *   .orderBy(asc(cars.year));
- * ```
- *
- * @see desc to sort in descending order
+ * @see ilike for a case-insensitive version of this condition
  */
-function asc(column) {
-    return sql `${column} asc`;
+function like(column, value) {
+    return sql `${column} like ${value}`;
 }
 /**
- * Used in sorting, this specifies that the given
- * column or expression should be sorted in descending
- * order.
+ * The inverse of like - this tests that a given column
+ * does not match a pattern, which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
  *
  * ## Examples
  *
  * ```ts
- * // Select users, with the most recently created
- * // records coming first.
- * db.select().from(users)
- *   .orderBy(desc(users.createdAt));
+ * // Select all cars that don't have "ROver" in their name.
+ * db.select().from(cars)
+ *   .where(notLike(cars.name, '%Rover%'))
  * ```
  *
- * @see asc to sort in ascending order
- */
-function desc(column) {
-    return sql `${column} desc`;
-}
-
-/**
- * This class is used to indicate a primitive param value that is used in `sql` tag.
- * It is only used on type level and is never instantiated at runtime.
- * If you see a value of this type in the code, its runtime value is actually the primitive param value.
+ * @see like for the inverse condition
+ * @see notIlike for a case-insensitive version of this condition
  */
-class FakePrimitiveParam {
-    static [entityKind] = 'FakePrimitiveParam';
-}
-function isSQLWrapper(value) {
-    return typeof value === 'object' && value !== null && 'getSQL' in value
-        && typeof value.getSQL === 'function';
-}
-function mergeQueries(queries) {
-    const result = { sql: '', params: [] };
-    for (const query of queries) {
-        result.sql += query.sql;
-        result.params.push(...query.params);
-        if (query.typings?.length) {
-            if (!result.typings) {
-                result.typings = [];
-            }
-            result.typings.push(...query.typings);
-        }
-    }
-    return result;
-}
-class StringChunk {
-    static [entityKind] = 'StringChunk';
-    value;
-    constructor(value) {
-        this.value = Array.isArray(value) ? value : [value];
-    }
-    getSQL() {
-        return new SQL([this]);
-    }
-}
-class SQL {
-    queryChunks;
-    static [entityKind] = 'SQL';
-    /** @internal */
-    decoder = noopDecoder;
-    shouldInlineParams = false;
-    constructor(queryChunks) {
-        this.queryChunks = queryChunks;
-    }
-    append(query) {
-        this.queryChunks.push(...query.queryChunks);
-        return this;
-    }
-    toQuery(config) {
-        return tracer.startActiveSpan('drizzle.buildSQL', (span) => {
-            const query = this.buildQueryFromSourceParams(this.queryChunks, config);
-            span?.setAttributes({
-                'drizzle.query.text': query.sql,
-                'drizzle.query.params': JSON.stringify(query.params),
-            });
-            return query;
-        });
-    }
-    buildQueryFromSourceParams(chunks, _config) {
-        const config = Object.assign({}, _config, {
-            inlineParams: _config.inlineParams || this.shouldInlineParams,
-            paramStartIndex: _config.paramStartIndex || { value: 0 },
-        });
-        const { escapeName, escapeParam, prepareTyping, inlineParams, paramStartIndex, } = config;
-        return mergeQueries(chunks.map((chunk) => {
-            if (is(chunk, StringChunk)) {
-                return { sql: chunk.value.join(''), params: [] };
-            }
-            if (is(chunk, Name)) {
-                return { sql: escapeName(chunk.value), params: [] };
-            }
-            if (chunk === undefined) {
-                return { sql: '', params: [] };
-            }
-            if (Array.isArray(chunk)) {
-                const result = [new StringChunk('(')];
-                for (const [i, p] of chunk.entries()) {
-                    result.push(p);
-                    if (i < chunk.length - 1) {
-                        result.push(new StringChunk(', '));
-                    }
-                }
-                result.push(new StringChunk(')'));
-                return this.buildQueryFromSourceParams(result, config);
-            }
-            if (is(chunk, SQL)) {
-                return this.buildQueryFromSourceParams(chunk.queryChunks, {
-                    ...config,
-                    inlineParams: inlineParams || chunk.shouldInlineParams,
-                });
-            }
-            if (is(chunk, Table)) {
-                const schemaName = chunk[Table.Symbol.Schema];
-                const tableName = chunk[Table.Symbol.Name];
-                return {
-                    sql: schemaName === undefined
-                        ? escapeName(tableName)
-                        : escapeName(schemaName) + '.' + escapeName(tableName),
-                    params: [],
-                };
-            }
-            if (is(chunk, Column)) {
-                return { sql: escapeName(chunk.table[Table.Symbol.Name]) + '.' + escapeName(chunk.name), params: [] };
-            }
-            if (is(chunk, View)) {
-                const schemaName = chunk[ViewBaseConfig].schema;
-                const viewName = chunk[ViewBaseConfig].name;
-                return {
-                    sql: schemaName === undefined
-                        ? escapeName(viewName)
-                        : escapeName(schemaName) + '.' + escapeName(viewName),
-                    params: [],
-                };
-            }
-            if (is(chunk, Param)) {
-                const mappedValue = (chunk.value === null) ? null : chunk.encoder.mapToDriverValue(chunk.value);
-                if (is(mappedValue, SQL)) {
-                    return this.buildQueryFromSourceParams([mappedValue], config);
-                }
-                if (inlineParams) {
-                    return { sql: this.mapInlineParam(mappedValue, config), params: [] };
-                }
-                let typings;
-                if (prepareTyping !== undefined) {
-                    typings = [prepareTyping(chunk.encoder)];
-                }
-                return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
-            }
-            if (is(chunk, Placeholder)) {
-                return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
-            }
-            if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
-                return { sql: escapeName(chunk.fieldAlias), params: [] };
-            }
-            if (is(chunk, Subquery)) {
-                if (chunk[SubqueryConfig].isWith) {
-                    return { sql: escapeName(chunk[SubqueryConfig].alias), params: [] };
-                }
-                return this.buildQueryFromSourceParams([
-                    new StringChunk('('),
-                    chunk[SubqueryConfig].sql,
-                    new StringChunk(') '),
-                    new Name(chunk[SubqueryConfig].alias),
-                ], config);
-            }
-            // if (is(chunk, Placeholder)) {
-            // 	return {sql: escapeParam}
-            if (isSQLWrapper(chunk)) {
-                return this.buildQueryFromSourceParams([
-                    new StringChunk('('),
-                    chunk.getSQL(),
-                    new StringChunk(')'),
-                ], config);
-            }
-            if (is(chunk, Relation)) {
-                return this.buildQueryFromSourceParams([
-                    chunk.sourceTable,
-                    new StringChunk('.'),
-                    sql.identifier(chunk.fieldName),
-                ], config);
-            }
-            if (inlineParams) {
-                return { sql: this.mapInlineParam(chunk, config), params: [] };
-            }
-            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk] };
-        }));
-    }
-    mapInlineParam(chunk, { escapeString }) {
-        if (chunk === null) {
-            return 'null';
-        }
-        if (typeof chunk === 'number' || typeof chunk === 'boolean') {
-            return chunk.toString();
-        }
-        if (typeof chunk === 'string') {
-            return escapeString(chunk);
-        }
-        if (typeof chunk === 'object') {
-            const mappedValueAsString = chunk.toString();
-            if (mappedValueAsString === '[object Object]') {
-                return escapeString(JSON.stringify(chunk));
-            }
-            return escapeString(mappedValueAsString);
-        }
-        throw new Error('Unexpected param value: ' + chunk);
-    }
-    getSQL() {
-        return this;
-    }
-    as(alias) {
-        // TODO: remove with deprecated overloads
-        if (alias === undefined) {
-            return this;
-        }
-        return new SQL.Aliased(this, alias);
-    }
-    mapWith(decoder) {
-        this.decoder = typeof decoder === 'function' ? { mapFromDriverValue: decoder } : decoder;
-        return this;
-    }
-    inlineParams() {
-        this.shouldInlineParams = true;
-        return this;
-    }
+function notLike(column, value) {
+    return sql `${column} not like ${value}`;
 }
 /**
- * Any DB name (table, column, index etc.)
- */
-class Name {
-    value;
-    static [entityKind] = 'Name';
-    brand;
-    constructor(value) {
-        this.value = value;
-    }
-    getSQL() {
-        return new SQL([this]);
-    }
+ * Case-insensitively compare a column to a pattern,
+ * which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
+ *
+ * Unlike like, this performs a case-insensitive comparison.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select all cars with 'Turbo' in their names.
+ * db.select().from(cars)
+ *   .where(ilike(cars.name, '%Turbo%'))
+ * ```
+ *
+ * @see like for a case-sensitive version of this condition
+ */
+function ilike(column, value) {
+    return sql `${column} ilike ${value}`;
 }
 /**
- * Any DB name (table, column, index etc.)
- * @deprecated Use `sql.identifier` instead.
+ * The inverse of ilike - this case-insensitively tests that a given column
+ * does not match a pattern, which can include `%` and `_`
+ * characters to match multiple variations. Including `%`
+ * in the pattern matches zero or more characters, and including
+ * `_` will match a single character.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select all cars that don't have "Rover" in their name.
+ * db.select().from(cars)
+ *   .where(notLike(cars.name, '%Rover%'))
+ * ```
+ *
+ * @see ilike for the inverse condition
+ * @see notLike for a case-sensitive version of this condition
  */
-function name(value) {
-    return new Name(value);
-}
-function isDriverValueEncoder(value) {
-    return typeof value === 'object' && value !== null && 'mapToDriverValue' in value
-        && typeof value.mapToDriverValue === 'function';
-}
-const noopDecoder = {
-    mapFromDriverValue: (value) => value,
-};
-const noopEncoder = {
-    mapToDriverValue: (value) => value,
-};
-const noopMapper = {
-    ...noopDecoder,
-    ...noopEncoder,
-};
-/** Parameter value that is optionally bound to an encoder (for example, a column). */
-class Param {
-    value;
-    encoder;
-    static [entityKind] = 'Param';
-    brand;
-    /**
-     * @param value - Parameter value
-     * @param encoder - Encoder to convert the value to a driver parameter
-     */
-    constructor(value, encoder = noopEncoder) {
-        this.value = value;
-        this.encoder = encoder;
-    }
-    getSQL() {
-        return new SQL([this]);
-    }
-}
-/** @deprecated Use `sql.param` instead. */
-function param(value, encoder) {
-    return new Param(value, encoder);
+function notIlike(column, value) {
+    return sql `${column} not ilike ${value}`;
 }
-/*
-    The type of `params` is specified as `SQLSourceParam[]`, but that's slightly incorrect -
-    in runtime, users won't pass `FakePrimitiveParam` instances as `params` - they will pass primitive values
-    which will be wrapped in `Param` using `buildChunksFromParam(...)`. That's why the overload
-    specify `params` as `any[]` and not as `SQLSourceParam[]`. This type is used to make our lives easier and
-    the type checker happy.
-*/
-function sql(strings, ...params) {
-    const queryChunks = [];
-    if (params.length > 0 || (strings.length > 0 && strings[0] !== '')) {
-        queryChunks.push(new StringChunk(strings[0]));
-    }
-    for (const [paramIndex, param] of params.entries()) {
-        queryChunks.push(param, new StringChunk(strings[paramIndex + 1]));
+function arrayContains(column, values) {
+    if (Array.isArray(values)) {
+        if (values.length === 0) {
+            throw new Error('arrayContains requires at least one value');
+        }
+        const array = sql `${bindIfParam(values, column)}`;
+        return sql `${column} @> ${array}`;
     }
-    return new SQL(queryChunks);
+    return sql `${column} @> ${bindIfParam(values, column)}`;
 }
-(function (sql) {
-    function empty() {
-        return new SQL([]);
-    }
-    sql.empty = empty;
-    /** @deprecated - use `sql.join()` */
-    function fromList(list) {
-        return new SQL(list);
-    }
-    sql.fromList = fromList;
-    /**
-     * Convenience function to create an SQL query from a raw string.
-     * @param str The raw SQL query string.
-     */
-    function raw(str) {
-        return new SQL([new StringChunk(str)]);
-    }
-    sql.raw = raw;
-    /**
-     * Join a list of SQL chunks with a separator.
-     * @example
-     * ```ts
-     * const query = sql.join([sql`a`, sql`b`, sql`c`]);
-     * // sql`abc`
-     * ```
-     * @example
-     * ```ts
-     * const query = sql.join([sql`a`, sql`b`, sql`c`], sql`, `);
-     * // sql`a, b, c`
-     * ```
-     */
-    function join(chunks, separator) {
-        const result = [];
-        for (const [i, chunk] of chunks.entries()) {
-            if (i > 0 && separator !== undefined) {
-                result.push(separator);
-            }
-            result.push(chunk);
+function arrayContained(column, values) {
+    if (Array.isArray(values)) {
+        if (values.length === 0) {
+            throw new Error('arrayContained requires at least one value');
         }
-        return new SQL(result);
-    }
-    sql.join = join;
-    /**
-     * Create a SQL chunk that represents a DB identifier (table, column, index etc.).
-     * When used in a query, the identifier will be escaped based on the DB engine.
-     * For example, in PostgreSQL, identifiers are escaped with double quotes.
-     *
-     * **WARNING: This function does not offer any protection against SQL injections, so you must validate any user input beforehand.**
-     *
-     * @example ```ts
-     * const query = sql`SELECT * FROM ${sql.identifier('my-table')}`;
-     * // 'SELECT * FROM "my-table"'
-     * ```
-     */
-    function identifier(value) {
-        return new Name(value);
-    }
-    sql.identifier = identifier;
-    function placeholder(name) {
-        return new Placeholder(name);
-    }
-    sql.placeholder = placeholder;
-    function param(value, encoder) {
-        return new Param(value, encoder);
+        const array = sql `${bindIfParam(values, column)}`;
+        return sql `${column} <@ ${array}`;
     }
-    sql.param = param;
-})(sql || (sql = {}));
-(function (SQL) {
-    class Aliased {
-        sql;
-        fieldAlias;
-        static [entityKind] = 'SQL.Aliased';
-        /** @internal */
-        isSelectionField = false;
-        constructor(sql, fieldAlias) {
-            this.sql = sql;
-            this.fieldAlias = fieldAlias;
-        }
-        getSQL() {
-            return this.sql;
-        }
-        /** @internal */
-        clone() {
-            return new Aliased(this.sql, this.fieldAlias);
+    return sql `${column} <@ ${bindIfParam(values, column)}`;
+}
+function arrayOverlaps(column, values) {
+    if (Array.isArray(values)) {
+        if (values.length === 0) {
+            throw new Error('arrayOverlaps requires at least one value');
         }
+        const array = sql `${bindIfParam(values, column)}`;
+        return sql `${column} && ${array}`;
     }
-    SQL.Aliased = Aliased;
-})(SQL || (SQL = {}));
-class Placeholder {
-    name;
-    static [entityKind] = 'Placeholder';
-    constructor(name) {
-        this.name = name;
-    }
-    getSQL() {
-        return new SQL([this]);
-    }
+    return sql `${column} && ${bindIfParam(values, column)}`;
 }
-/** @deprecated Use `sql.placeholder` instead. */
-function placeholder(name) {
-    return new Placeholder(name);
+
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in ascending
+ * order. By the SQL standard, ascending order is the
+ * default, so it is not usually necessary to specify
+ * ascending sort order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Return cars, starting with the oldest models
+ * // and going in ascending order to the newest.
+ * db.select().from(cars)
+ *   .orderBy(asc(cars.year));
+ * ```
+ *
+ * @see desc to sort in descending order
+ */
+function asc(column) {
+    return sql `${column} asc`;
 }
-function fillPlaceholders(params, values) {
-    return params.map((p) => {
-        if (is(p, Placeholder)) {
-            if (!(p.name in values)) {
-                throw new Error(`No value for placeholder "${p.name}" was provided`);
-            }
-            return values[p.name];
-        }
-        return p;
-    });
+/**
+ * Used in sorting, this specifies that the given
+ * column or expression should be sorted in descending
+ * order.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select users, with the most recently created
+ * // records coming first.
+ * db.select().from(users)
+ *   .orderBy(desc(users.createdAt));
+ * ```
+ *
+ * @see asc to sort in ascending order
+ */
+function desc(column) {
+    return sql `${column} desc`;
 }
-// Defined separately from the Column class to resolve circular dependency
-Column.prototype.getSQL = function () {
-    return new SQL([this]);
-};
 
 class ColumnAliasProxyHandler {
     table;
@@ -4049,5 +3904,170 @@ function mapColumnsInSQLToAlias(query, alias) {
     }));
 }
 
-export { PgArrayBuilder as $, getOrderByOperators as A, normalizeRelation as B, ColumnBuilder as C, DrizzleError as D, and as E, eq as F, aliasedTable as G, applyMixins as H, getTableColumns as I, TypedQueryBuilder as J, getTableLikeName as K, PgColumnBuilder as L, Many as M, PgColumn as N, One as O, PgDialect as P, QueryPromise as Q, pgTableWithSchema as R, SQL as S, Table as T, pgViewWithSchema as U, ViewBaseConfig as V, WithSubquery as W, pgMaterializedViewWithSchema as X, CheckBuilder as Y, Check as Z, check as _, extractTablesRelationalConfig as a, PgView as a$, PgArray as a0, PgDateBuilder as a1, PgDate as a2, PgDateStringBuilder as a3, PgDateString as a4, date as a5, PgJsonBuilder as a6, PgJson as a7, json as a8, PgJsonbBuilder as a9, PrimaryKeyBuilder as aA, PrimaryKey as aB, PgSelectQueryBuilder as aC, PgSelect as aD, InlineForeignKeys as aE, PgTable as aF, pgTable as aG, pgTableCreator as aH, unique as aI, uniqueKeyName as aJ, UniqueConstraintBuilder as aK, UniqueOnConstraintBuilder as aL, UniqueConstraint as aM, getTableConfig as aN, getViewConfig as aO, getMaterializedViewConfig as aP, parsePgNestedArray as aQ, parsePgArray as aR, makePgArray as aS, DefaultViewBuilderCore as aT, ViewBuilder as aU, ManualViewBuilder as aV, MaterializedViewBuilderCore as aW, MaterializedViewBuilder as aX, ManualMaterializedViewBuilder as aY, PgViewBase as aZ, PgViewConfig as a_, PgJsonb as aa, jsonb as ab, PgNumericBuilder as ac, PgNumeric as ad, numeric as ae, decimal as af, PgTimeBuilder as ag, PgTime as ah, time as ai, PgTimestampBuilder as aj, PgTimestamp as ak, PgTimestampStringBuilder as al, PgTimestampString as am, timestamp as an, PgUUIDBuilder as ao, PgUUID as ap, uuid as aq, ForeignKeyBuilder as ar, ForeignKey as as, foreignKey as at, IndexBuilderOn as au, IndexBuilder as av, Index as aw, index as ax, uniqueIndex as ay, primaryKey as az, Param as b, PgMaterializedViewConfig as b0, PgMaterializedView as b1, pgView as b2, pgMaterializedView as b3, ColumnAliasProxyHandler as b4, RelationTableAliasProxyHandler as b5, aliasedRelation as b6, hasOwnEntityKind as b7, bindIfParam as b8, ne as b9, createOne as bA, createMany as bB, FakePrimitiveParam as bC, isSQLWrapper as bD, StringChunk as bE, Name as bF, name as bG, isDriverValueEncoder as bH, noopDecoder as bI, noopEncoder as bJ, noopMapper as bK, param as bL, Placeholder as bM, placeholder as bN, TableName as bO, Schema as bP, Columns as bQ, OriginalName as bR, BaseName as bS, IsAlias as bT, ExtraConfigBuilder as bU, isTable as bV, iife as bW, or as ba, not as bb, gt as bc, gte as bd, lt as be, lte as bf, inArray as bg, notInArray as bh, isNull as bi, isNotNull as bj, exists as bk, notExists as bl, between as bm, notBetween as bn, like as bo, notLike as bp, ilike as bq, notIlike as br, arrayContains as bs, arrayContained as bt, arrayOverlaps as bu, asc as bv, desc as bw, Relation as bx, Relations as by, relations as bz, createTableRelationsHelpers as c, mapUpdateSet as d, entityKind as e, fillPlaceholders as f, mapRelationalRow as g, QueryBuilder as h, is as i, SelectionProxyHandler as j, PgSelectBuilder as k, TransactionRollbackError as l, mapResultRow as m, TableAliasProxyHandler as n, orderSelectedFields as o, Column as p, getTableName as q, Subquery as r, sql as s, tracer as t, SubqueryConfig as u, View as v, aliasedTableColumn as w, getOperators as x, mapColumnsInSQLToAlias as y, mapColumnsInAliasedSQLToAlias as z };
-//# sourceMappingURL=alias-cf8e03cd.mjs.map
+exports.BaseName = BaseName;
+exports.Column = Column;
+exports.ColumnAliasProxyHandler = ColumnAliasProxyHandler;
+exports.ColumnBuilder = ColumnBuilder;
+exports.Columns = Columns;
+exports.DefaultViewBuilderCore = DefaultViewBuilderCore;
+exports.DrizzleError = DrizzleError;
+exports.ExtraConfigBuilder = ExtraConfigBuilder;
+exports.FakePrimitiveParam = FakePrimitiveParam;
+exports.ForeignKey = ForeignKey;
+exports.ForeignKeyBuilder = ForeignKeyBuilder;
+exports.InlineForeignKeys = InlineForeignKeys;
+exports.IsAlias = IsAlias;
+exports.ManualMaterializedViewBuilder = ManualMaterializedViewBuilder;
+exports.ManualViewBuilder = ManualViewBuilder;
+exports.Many = Many;
+exports.MaterializedViewBuilder = MaterializedViewBuilder;
+exports.MaterializedViewBuilderCore = MaterializedViewBuilderCore;
+exports.Name = Name;
+exports.One = One;
+exports.OriginalName = OriginalName;
+exports.Param = Param;
+exports.PgArray = PgArray;
+exports.PgArrayBuilder = PgArrayBuilder;
+exports.PgColumn = PgColumn;
+exports.PgColumnBuilder = PgColumnBuilder;
+exports.PgDate = PgDate;
+exports.PgDateBuilder = PgDateBuilder;
+exports.PgDateString = PgDateString;
+exports.PgDateStringBuilder = PgDateStringBuilder;
+exports.PgDialect = PgDialect;
+exports.PgJson = PgJson;
+exports.PgJsonBuilder = PgJsonBuilder;
+exports.PgJsonb = PgJsonb;
+exports.PgJsonbBuilder = PgJsonbBuilder;
+exports.PgMaterializedView = PgMaterializedView;
+exports.PgMaterializedViewConfig = PgMaterializedViewConfig;
+exports.PgNumeric = PgNumeric;
+exports.PgNumericBuilder = PgNumericBuilder;
+exports.PgSelectBase = PgSelectBase;
+exports.PgSelectBuilder = PgSelectBuilder;
+exports.PgSelectQueryBuilderBase = PgSelectQueryBuilderBase;
+exports.PgTable = PgTable;
+exports.PgTime = PgTime;
+exports.PgTimeBuilder = PgTimeBuilder;
+exports.PgTimestamp = PgTimestamp;
+exports.PgTimestampBuilder = PgTimestampBuilder;
+exports.PgTimestampString = PgTimestampString;
+exports.PgTimestampStringBuilder = PgTimestampStringBuilder;
+exports.PgUUID = PgUUID;
+exports.PgUUIDBuilder = PgUUIDBuilder;
+exports.PgView = PgView;
+exports.PgViewBase = PgViewBase;
+exports.PgViewConfig = PgViewConfig;
+exports.Placeholder = Placeholder;
+exports.PrimaryKey = PrimaryKey;
+exports.PrimaryKeyBuilder = PrimaryKeyBuilder;
+exports.QueryBuilder = QueryBuilder;
+exports.QueryPromise = QueryPromise;
+exports.Relation = Relation;
+exports.RelationTableAliasProxyHandler = RelationTableAliasProxyHandler;
+exports.Relations = Relations;
+exports.SQL = SQL;
+exports.Schema = Schema;
+exports.SelectionProxyHandler = SelectionProxyHandler;
+exports.StringChunk = StringChunk;
+exports.Subquery = Subquery;
+exports.SubqueryConfig = SubqueryConfig;
+exports.Table = Table;
+exports.TableAliasProxyHandler = TableAliasProxyHandler;
+exports.TableName = TableName;
+exports.TransactionRollbackError = TransactionRollbackError;
+exports.TypedQueryBuilder = TypedQueryBuilder;
+exports.UniqueConstraint = UniqueConstraint;
+exports.UniqueConstraintBuilder = UniqueConstraintBuilder;
+exports.UniqueOnConstraintBuilder = UniqueOnConstraintBuilder;
+exports.View = View;
+exports.ViewBaseConfig = ViewBaseConfig;
+exports.ViewBuilder = ViewBuilder;
+exports.WithSubquery = WithSubquery;
+exports.aliasedRelation = aliasedRelation;
+exports.aliasedTable = aliasedTable;
+exports.aliasedTableColumn = aliasedTableColumn;
+exports.and = and;
+exports.applyMixins = applyMixins;
+exports.arrayContained = arrayContained;
+exports.arrayContains = arrayContains;
+exports.arrayOverlaps = arrayOverlaps;
+exports.asc = asc;
+exports.between = between;
+exports.bindIfParam = bindIfParam;
+exports.createMany = createMany;
+exports.createOne = createOne;
+exports.createTableRelationsHelpers = createTableRelationsHelpers;
+exports.date = date;
+exports.decimal = decimal;
+exports.desc = desc;
+exports.entityKind = entityKind;
+exports.eq = eq;
+exports.exists = exists;
+exports.extractTablesRelationalConfig = extractTablesRelationalConfig;
+exports.fillPlaceholders = fillPlaceholders;
+exports.foreignKey = foreignKey;
+exports.getOperators = getOperators;
+exports.getOrderByOperators = getOrderByOperators;
+exports.getTableColumns = getTableColumns;
+exports.getTableLikeName = getTableLikeName;
+exports.getTableName = getTableName;
+exports.gt = gt;
+exports.gte = gte;
+exports.hasOwnEntityKind = hasOwnEntityKind;
+exports.iife = iife;
+exports.ilike = ilike;
+exports.inArray = inArray;
+exports.is = is;
+exports.isDriverValueEncoder = isDriverValueEncoder;
+exports.isNotNull = isNotNull;
+exports.isNull = isNull;
+exports.isSQLWrapper = isSQLWrapper;
+exports.isTable = isTable;
+exports.json = json;
+exports.jsonb = jsonb;
+exports.like = like;
+exports.lt = lt;
+exports.lte = lte;
+exports.makePgArray = makePgArray;
+exports.mapColumnsInAliasedSQLToAlias = mapColumnsInAliasedSQLToAlias;
+exports.mapColumnsInSQLToAlias = mapColumnsInSQLToAlias;
+exports.mapRelationalRow = mapRelationalRow;
+exports.mapResultRow = mapResultRow;
+exports.mapUpdateSet = mapUpdateSet;
+exports.name = name;
+exports.ne = ne;
+exports.noopDecoder = noopDecoder;
+exports.noopEncoder = noopEncoder;
+exports.noopMapper = noopMapper;
+exports.normalizeRelation = normalizeRelation;
+exports.not = not;
+exports.notBetween = notBetween;
+exports.notExists = notExists;
+exports.notIlike = notIlike;
+exports.notInArray = notInArray;
+exports.notLike = notLike;
+exports.numeric = numeric;
+exports.or = or;
+exports.orderSelectedFields = orderSelectedFields;
+exports.param = param;
+exports.parsePgArray = parsePgArray;
+exports.parsePgNestedArray = parsePgNestedArray;
+exports.pgMaterializedView = pgMaterializedView;
+exports.pgMaterializedViewWithSchema = pgMaterializedViewWithSchema;
+exports.pgTable = pgTable;
+exports.pgTableCreator = pgTableCreator;
+exports.pgTableWithSchema = pgTableWithSchema;
+exports.pgView = pgView;
+exports.pgViewWithSchema = pgViewWithSchema;
+exports.placeholder = placeholder;
+exports.primaryKey = primaryKey;
+exports.relations = relations;
+exports.sql = sql;
+exports.time = time;
+exports.timestamp = timestamp;
+exports.tracer = tracer;
+exports.unique = unique;
+exports.uniqueKeyName = uniqueKeyName;
+exports.uuid = uuid;
+//# sourceMappingURL=alias-aa343af5.cjs.map