drizzle-orm 0.28.0-1f79521 → 0.28.0-5dd9190

package/{alias-d10e3a09.cjs → alias-3f5ac719.cjs}

@@ -25,7 +25,7 @@ function is(value, type) {
     return false;
 }
 
-var _a$U;
+var _a$V;
 /*
     `Column` only accepts a full `ColumnConfig` as its generic.
     To infer parts of the config, use `AnyColumn` that accepts a partial config.
@@ -34,12 +34,18 @@ var _a$U;
 class Column {
     constructor(table, config) {
         this.table = table;
+        this.enumValues = undefined;
         this.config = config;
         this.name = config.name;
         this.notNull = config.notNull;
         this.default = config.default;
         this.hasDefault = config.hasDefault;
         this.primary = config.primaryKey;
+        this.isUnique = config.isUnique;
+        this.uniqueName = config.uniqueName;
+        this.uniqueType = config.uniqueType;
+        this.dataType = config.dataType;
+        this.columnType = config.columnType;
     }
     mapFromDriverValue(value) {
         return value;
@@ -48,10 +54,10 @@ class Column {
         return value;
     }
 }
-_a$U = entityKind;
-Column[_a$U] = 'Column';
+_a$V = entityKind;
+Column[_a$V] = 'Column';
 
-var _a$T, _b$J, _c$d, _d$7;
+var _a$U, _b$K, _c$e, _d$7;
 /** @internal */
 const TableName = Symbol.for('drizzle:Name');
 /** @internal */
@@ -70,17 +76,20 @@ const IsDrizzleTable = Symbol.for('drizzle:IsDrizzleTable');
 class Table {
     constructor(name, schema, baseName) {
         /** @internal */
-        this[_b$J] = false;
+        this[_b$K] = false;
         /** @internal */
-        this[_c$d] = undefined;
+        this[_c$e] = undefined;
         this[_d$7] = true;
         this[TableName] = this[OriginalName] = name;
         this[Schema] = schema;
         this[BaseName] = baseName;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
-_a$T = entityKind, _b$J = IsAlias, _c$d = ExtraConfigBuilder, _d$7 = IsDrizzleTable;
-Table[_a$T] = 'Table';
+_a$U = entityKind, _b$K = IsAlias, _c$e = ExtraConfigBuilder, _d$7 = IsDrizzleTable;
+Table[_a$U] = 'Table';
 /** @internal */
 Table.Symbol = {
     Name: TableName,
@@ -98,7 +107,7 @@ function getTableName(table) {
     return table[TableName];
 }
 
-var _a$S, _b$I;
+var _a$T, _b$J;
 class CheckBuilder {
     constructor(name, value) {
         this.name = name;
@@ -109,8 +118,8 @@ class CheckBuilder {
         return new Check(table, this);
     }
 }
-_a$S = entityKind;
-CheckBuilder[_a$S] = 'PgCheckBuilder';
+_a$T = entityKind;
+CheckBuilder[_a$T] = 'PgCheckBuilder';
 class Check {
     constructor(table, builder) {
         this.table = table;
@@ -118,26 +127,26 @@ class Check {
         this.value = builder.value;
     }
 }
-_b$I = entityKind;
-Check[_b$I] = 'PgCheck';
+_b$J = entityKind;
+Check[_b$J] = 'PgCheck';
 function check(name, value) {
     return new CheckBuilder(name, value);
 }
 
-var _a$R, _b$H, _c$c;
+var _a$S, _b$I, _c$d;
 /** @internal */
 const InlineForeignKeys = Symbol.for('drizzle:PgInlineForeignKeys');
 class PgTable extends Table {
     constructor() {
         super(...arguments);
         /**@internal */
-        this[_b$H] = [];
+        this[_b$I] = [];
         /** @internal */
-        this[_c$c] = undefined;
+        this[_c$d] = undefined;
     }
 }
-_a$R = entityKind, _b$H = InlineForeignKeys, _c$c = Table.Symbol.ExtraConfigBuilder;
-PgTable[_a$R] = 'PgTable';
+_a$S = entityKind, _b$I = InlineForeignKeys, _c$d = Table.Symbol.ExtraConfigBuilder;
+PgTable[_a$S] = 'PgTable';
 /** @internal */
 PgTable.Symbol = Object.assign({}, Table.Symbol, {
     InlineForeignKeys: InlineForeignKeys,
@@ -166,7 +175,7 @@ function pgTableCreator(customizeTableName) {
     };
 }
 
-var _a$Q;
+var _a$R;
 const ViewBaseConfig = Symbol.for('drizzle:ViewBaseConfig');
 class View {
     constructor({ name, schema, selectedFields, query }) {
@@ -180,11 +189,14 @@ class View {
             isAlias: false,
         };
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
-_a$Q = entityKind;
-View[_a$Q] = 'View';
+_a$R = entityKind;
+View[_a$R] = 'View';
 
-var _a$P, _b$G;
+var _a$Q, _b$H;
 class ForeignKeyBuilder {
     constructor(config, actions) {
         /** @internal */
@@ -213,8 +225,8 @@ class ForeignKeyBuilder {
         return new ForeignKey(table, this);
     }
 }
-_a$P = entityKind;
-ForeignKeyBuilder[_a$P] = 'PgForeignKeyBuilder';
+_a$Q = entityKind;
+ForeignKeyBuilder[_a$Q] = 'PgForeignKeyBuilder';
 class ForeignKey {
     constructor(table, builder) {
         this.table = table;
@@ -235,8 +247,8 @@ class ForeignKey {
         return `${chunks.join('_')}_fk`;
     }
 }
-_b$G = entityKind;
-ForeignKey[_b$G] = 'PgForeignKey';
+_b$H = entityKind;
+ForeignKey[_b$H] = 'PgForeignKey';
 function foreignKey(config) {
     function mappedConfig() {
         const { columns, foreignColumns } = config;
@@ -248,7 +260,7 @@ function foreignKey(config) {
     return new ForeignKeyBuilder(mappedConfig);
 }
 
-var _a$O, _b$F, _c$b;
+var _a$P, _b$G, _c$c;
 class IndexBuilderOn {
     constructor(unique, name) {
         this.unique = unique;
@@ -261,8 +273,8 @@ class IndexBuilderOn {
         return new IndexBuilder(columns, this.unique, true, this.name);
     }
 }
-_a$O = entityKind;
-IndexBuilderOn[_a$O] = 'PgIndexBuilderOn';
+_a$P = entityKind;
+IndexBuilderOn[_a$P] = 'PgIndexBuilderOn';
 class IndexBuilder {
     constructor(columns, unique, only, name) {
         this.config = {
@@ -305,15 +317,15 @@ class IndexBuilder {
         return new Index(this.config, table);
     }
 }
-_b$F = entityKind;
-IndexBuilder[_b$F] = 'PgIndexBuilder';
+_b$G = entityKind;
+IndexBuilder[_b$G] = 'PgIndexBuilder';
 class Index {
     constructor(config, table) {
         this.config = { ...config, table };
     }
 }
-_c$b = entityKind;
-Index[_c$b] = 'PgIndex';
+_c$c = entityKind;
+Index[_c$c] = 'PgIndex';
 function index(name) {
     return new IndexBuilderOn(false, name);
 }
@@ -321,7 +333,7 @@ function uniqueIndex(name) {
     return new IndexBuilderOn(true, name);
 }
 
-var _a$N, _b$E;
+var _a$O, _b$F;
 function primaryKey(...columns) {
     return new PrimaryKeyBuilder(columns);
 }
@@ -334,8 +346,8 @@ class PrimaryKeyBuilder {
         return new PrimaryKey(table, this.columns);
     }
 }
-_a$N = entityKind;
-PrimaryKeyBuilder[_a$N] = 'PgPrimaryKeyBuilder';
+_a$O = entityKind;
+PrimaryKeyBuilder[_a$O] = 'PgPrimaryKeyBuilder';
 class PrimaryKey {
     constructor(table, columns) {
         this.table = table;
@@ -345,8 +357,58 @@ class PrimaryKey {
         return `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
     }
 }
+_b$F = entityKind;
+PrimaryKey[_b$F] = 'PgPrimaryKey';
+
+var _a$N, _b$E, _c$b;
+function unique(name) {
+    return new UniqueOnConstraintBuilder(name);
+}
+function uniqueKeyName(table, columns) {
+    return `${table[PgTable.Symbol.Name]}_${columns.join('_')}_unique`;
+}
+class UniqueConstraintBuilder {
+    constructor(columns, name) {
+        this.name = name;
+        /** @internal */
+        this.nullsNotDistinctConfig = false;
+        this.columns = columns;
+    }
+    nullsNotDistinct() {
+        this.nullsNotDistinctConfig = true;
+        return this;
+    }
+    /** @internal */
+    build(table) {
+        return new UniqueConstraint(table, this.columns, this.nullsNotDistinctConfig, this.name);
+    }
+}
+_a$N = entityKind;
+UniqueConstraintBuilder[_a$N] = 'PgUniqueConstraintBuilder';
+class UniqueOnConstraintBuilder {
+    constructor(name) {
+        this.name = name;
+    }
+    on(...columns) {
+        return new UniqueConstraintBuilder(columns, this.name);
+    }
+}
 _b$E = entityKind;
-PrimaryKey[_b$E] = 'PgPrimaryKey';
+UniqueOnConstraintBuilder[_b$E] = 'PgUniqueOnConstraintBuilder';
+class UniqueConstraint {
+    constructor(table, columns, nullsNotDistinct, name) {
+        this.table = table;
+        this.nullsNotDistinct = false;
+        this.columns = columns;
+        this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+        this.nullsNotDistinct = nullsNotDistinct;
+    }
+    getName() {
+        return this.name;
+    }
+}
+_c$b = entityKind;
+UniqueConstraint[_c$b] = 'PgUniqueConstraint';
 
 var _a$M, _b$D, _c$a;
 const SubqueryConfig = Symbol.for('drizzle:SubqueryConfig');
@@ -359,6 +421,9 @@ class Subquery {
             isWith,
         };
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _a$M = entityKind;
 Subquery[_a$M] = 'Subquery';
@@ -938,12 +1003,9 @@ class PgDialect {
         return sql `${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
     }
     buildInsertQuery({ table, values, onConflict, returning }) {
-        const isSingleValue = values.length === 1;
         const valuesSqlList = [];
         const columns = table[Table.Symbol.Columns];
-        const colEntries = isSingleValue
-            ? Object.keys(values[0]).map((fieldName) => [fieldName, columns[fieldName]])
-            : Object.entries(columns);
+        const colEntries = Object.entries(columns);
         const insertOrder = colEntries.map(([, column]) => sql.identifier(column.name));
         for (const [valueIndex, value] of values.entries()) {
             const valueList = [];
@@ -1502,10 +1564,10 @@ class PgDialect {
         }
         else {
             const aliasedColumns = Object.fromEntries(Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]));
-            const aliasedRelations = Object.fromEntries(Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]));
-            const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
             if (config.where) {
-                const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
+                const whereSql = typeof config.where === 'function'
+                    ? config.where(aliasedColumns, getOperators())
+                    : config.where;
                 where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
             }
             const fieldsSelection = [];
@@ -1549,7 +1611,7 @@ class PgDialect {
             // Figure out which extras to select
             if (config.extras) {
                 extras = typeof config.extras === 'function'
-                    ? config.extras(aliasedFields, { sql })
+                    ? config.extras(aliasedColumns, { sql })
                     : config.extras;
                 for (const [tsKey, value] of Object.entries(extras)) {
                     fieldsSelection.push({
@@ -1571,7 +1633,7 @@ class PgDialect {
                 });
             }
             let orderByOrig = typeof config.orderBy === 'function'
-                ? config.orderBy(aliasedFields, orderByOperators)
+                ? config.orderBy(aliasedColumns, getOrderByOperators())
                 : config.orderBy ?? [];
             if (!Array.isArray(orderByOrig)) {
                 orderByOrig = [orderByOrig];
@@ -1597,7 +1659,11 @@ class PgDialect {
                     tableNamesMap,
                     table: fullSchema[relationTableTsName],
                     tableConfig: schema[relationTableTsName],
-                    queryConfig: selectedRelationConfigValue,
+                    queryConfig: is(relation, One)
+                        ? (selectedRelationConfigValue === true
+                            ? { limit: 1 }
+                            : { ...selectedRelationConfigValue, limit: 1 })
+                        : selectedRelationConfigValue,
                     tableAlias: relationTableAlias,
                     joinOn,
                     nestedQueryRelation: relation,
@@ -1624,7 +1690,6 @@ class PgDialect {
             throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
         }
         let result;
-        const needsSubquery = where || limit !== undefined || offset !== undefined || orderBy.length > 0;
         where = and(joinOn, where);
         if (nestedQueryRelation) {
             let field = sql `json_build_array(${sql.join(selection.map(({ field, tsKey, isJson }) => isJson
@@ -1644,6 +1709,7 @@ class PgDialect {
                     relationTableTsKey: tableConfig.tsName,
                     selection,
                 }];
+            const needsSubquery = limit !== undefined || offset !== undefined || orderBy.length > 0;
             if (needsSubquery) {
                 result = this.buildSelectQuery({
                     table: aliasedTable(table, tableAlias),
@@ -1680,57 +1746,19 @@ class PgDialect {
             });
         }
         else {
-            if (needsSubquery) {
-                const nestedSelection = selection.filter(({ field }) => !is(field, Column));
-                nestedSelection.splice(0, 0, {
-                    dbKey: '*',
-                    tsKey: '*',
-                    field: sql `${sql.identifier(tableAlias)}.*`,
-                    isJson: false,
-                    relationTableTsKey: tableConfig.tsName,
-                    selection: [],
-                });
-                result = this.buildSelectQuery({
-                    table: aliasedTable(table, tableAlias),
-                    fields: {},
-                    fieldsFlat: nestedSelection.map(({ field }) => ({
-                        path: [],
-                        field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-                    })),
-                    joins,
-                });
-                result = this.buildSelectQuery({
-                    table: new Subquery(result, {}, tableAlias),
-                    fields: {},
-                    fieldsFlat: selection.map(({ field }) => ({
-                        path: [],
-                        field: is(field, Column)
-                            ? sql `${sql.identifier(field.name)}`
-                            : is(field, SQL.Aliased)
-                                ? sql `${sql.identifier(field.fieldAlias)}`
-                                : field,
-                    })),
-                    where,
-                    limit,
-                    offset,
-                    orderBy,
-                });
-            }
-            else {
-                result = this.buildSelectQuery({
-                    table: aliasedTable(table, tableAlias),
-                    fields: {},
-                    fieldsFlat: selection.map(({ field }) => ({
-                        path: [],
-                        field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
-                    })),
-                    joins,
-                    where,
-                    limit,
-                    offset,
-                    orderBy,
-                });
-            }
+            result = this.buildSelectQuery({
+                table: aliasedTable(table, tableAlias),
+                fields: {},
+                fieldsFlat: selection.map(({ field }) => ({
+                    path: [],
+                    field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
+                })),
+                joins,
+                where,
+                limit,
+                offset,
+                orderBy,
+            });
         }
         return {
             tableTsKey: tableConfig.tsName,
@@ -2456,6 +2484,7 @@ function getTableConfig(table) {
     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];
@@ -2468,6 +2497,9 @@ function getTableConfig(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));
             }
@@ -2482,6 +2514,7 @@ function getTableConfig(table) {
         foreignKeys,
         checks,
         primaryKeys,
+        uniqueConstraints,
         name,
         schema,
     };
@@ -2576,12 +2609,18 @@ function makePgArray(array) {
 var _a$A;
 // To understand how to use `ColumnBuilder` and `AnyColumnBuilder`, see `Column` and `AnyColumn` documentation.
 class ColumnBuilder {
-    constructor(name) {
+    constructor(name, dataType, columnType) {
         this.config = {
             name,
             notNull: false,
             default: undefined,
+            hasDefault: false,
             primaryKey: false,
+            isUnique: false,
+            uniqueName: undefined,
+            uniqueType: undefined,
+            dataType,
+            columnType,
         };
     }
     $type() {
@@ -2618,10 +2657,16 @@ class PgColumnBuilder extends ColumnBuilder {
         this.foreignKeyConfigs.push({ ref, actions });
         return this;
     }
+    unique(name, config) {
+        this.config.isUnique = true;
+        this.config.uniqueName = name;
+        this.config.uniqueType = config?.nulls;
+        return this;
+    }
     /** @internal */
     buildForeignKeys(column, table) {
         return this.foreignKeyConfigs.map(({ ref, actions }) => {
-            return ((ref, actions) => {
+            return iife((ref, actions) => {
                 const builder = new ForeignKeyBuilder(() => {
                     const foreignColumn = ref();
                     return { columns: [column], foreignColumns: [foreignColumn] };
@@ -2633,7 +2678,7 @@ class PgColumnBuilder extends ColumnBuilder {
                     builder.onDelete(actions.onDelete);
                 }
                 return builder.build(table);
-            })(ref, actions);
+            }, ref, actions);
         });
     }
 }
@@ -2641,6 +2686,13 @@ _a$z = entityKind;
 PgColumnBuilder[_a$z] = 'PgColumnBuilder';
 // To understand how to use `PgColumn` and `AnyPgColumn`, see `Column` and `AnyColumn` documentation.
 class PgColumn extends Column {
+    constructor(table, config) {
+        if (!config.uniqueName) {
+            config.uniqueName = uniqueKeyName(table, [config.name]);
+        }
+        super(table, config);
+        this.table = table;
+    }
 }
 _b$w = entityKind;
 PgColumn[_b$w] = 'PgColumn';
@@ -2648,7 +2700,7 @@ PgColumn[_b$w] = 'PgColumn';
 var _a$y, _b$v;
 class PgArrayBuilder extends PgColumnBuilder {
     constructor(name, baseBuilder, size) {
-        super(name);
+        super(name, 'array', 'PgArray');
         this.config.baseBuilder = baseBuilder;
         this.config.size = size;
     }
@@ -2693,6 +2745,9 @@ PgArray[_b$v] = 'PgArray';
 
 var _a$x, _b$u, _c$7, _d$5;
 class PgBigInt53Builder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'number', 'PgBigInt53');
+    }
     /** @internal */
     build(table) {
         return new PgBigInt53(table, this.config);
@@ -2714,6 +2769,9 @@ class PgBigInt53 extends PgColumn {
 _b$u = entityKind;
 PgBigInt53[_b$u] = 'PgBigInt53';
 class PgBigInt64Builder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'bigint', 'PgBigInt64');
+    }
     /** @internal */
     build(table) {
         return new PgBigInt64(table, this.config);
@@ -2742,7 +2800,7 @@ function bigint(name, config) {
 var _a$w, _b$t, _c$6, _d$4;
 class PgBigSerial53Builder extends PgColumnBuilder {
     constructor(name) {
-        super(name);
+        super(name, 'number', 'PgBigSerial53');
         this.config.hasDefault = true;
         this.config.notNull = true;
     }
@@ -2768,7 +2826,7 @@ _b$t = entityKind;
 PgBigSerial53[_b$t] = 'PgBigSerial53';
 class PgBigSerial64Builder extends PgColumnBuilder {
     constructor(name) {
-        super(name);
+        super(name, 'bigint', 'PgBigSerial64');
         this.config.hasDefault = true;
     }
     /** @internal */
@@ -2798,6 +2856,9 @@ function bigserial(name, { mode }) {
 
 var _a$v, _b$s;
 class PgBooleanBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'boolean', 'PgBoolean');
+    }
     /** @internal */
     build(table) {
         return new PgBoolean(table, this.config);
@@ -2819,9 +2880,9 @@ function boolean(name) {
 var _a$u, _b$r;
 class PgCharBuilder extends PgColumnBuilder {
     constructor(name, config) {
-        super(name);
+        super(name, 'string', 'PgChar');
         this.config.length = config.length;
-        this.config.enumValues = (config.enum ?? []);
+        this.config.enumValues = config.enum;
     }
     /** @internal */
     build(table) {
@@ -2848,6 +2909,9 @@ function char(name, config = {}) {
 
 var _a$t, _b$q;
 class PgCidrBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'string', 'PgCidr');
+    }
     /** @internal */
     build(table) {
         return new PgCidr(table, this.config);
@@ -2869,7 +2933,7 @@ function cidr(name) {
 var _a$s, _b$p;
 class PgCustomColumnBuilder extends PgColumnBuilder {
     constructor(name, fieldConfig, customTypeParams) {
-        super(name);
+        super(name, 'custom', 'PgCustomColumn');
         this.config.fieldConfig = fieldConfig;
         this.config.customTypeParams = customTypeParams;
     }
@@ -2919,6 +2983,9 @@ PgDateColumnBaseBuilder[_a$r] = 'PgDateColumnBaseBuilder';
 
 var _a$q, _b$o, _c$5, _d$3;
 class PgDateBuilder extends PgDateColumnBaseBuilder {
+    constructor(name) {
+        super(name, 'date', 'PgDate');
+    }
     /** @internal */
     build(table) {
         return new PgDate(table, this.config);
@@ -2940,6 +3007,9 @@ class PgDate extends PgColumn {
 _b$o = entityKind;
 PgDate[_b$o] = 'PgDate';
 class PgDateStringBuilder extends PgDateColumnBaseBuilder {
+    constructor(name) {
+        super(name, 'string', 'PgDateString');
+    }
     /** @internal */
     build(table) {
         return new PgDateString(table, this.config);
@@ -2963,6 +3033,9 @@ function date(name, config) {
 
 var _a$p, _b$n;
 class PgDoublePrecisionBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'number', 'PgDoublePrecision');
+    }
     /** @internal */
     build(table) {
         return new PgDoublePrecision(table, this.config);
@@ -2990,11 +3063,11 @@ function doublePrecision(name) {
 var _a$o, _b$m;
 const isPgEnumSym = Symbol.for('drizzle:isPgEnum');
 function isPgEnum(obj) {
-    return !!obj && typeof obj === 'function' && isPgEnumSym in obj;
+    return !!obj && typeof obj === 'function' && isPgEnumSym in obj && obj[isPgEnumSym] === true;
 }
 class PgEnumColumnBuilder extends PgColumnBuilder {
     constructor(name, enumInstance) {
-        super(name);
+        super(name, 'string', 'PgEnumColumn');
         this.config.enum = enumInstance;
     }
     /** @internal */
@@ -3029,6 +3102,9 @@ function pgEnum(enumName, values) {
 
 var _a$n, _b$l;
 class PgInetBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'string', 'PgInet');
+    }
     /** @internal */
     build(table) {
         return new PgInet(table, this.config);
@@ -3049,6 +3125,9 @@ function inet(name) {
 
 var _a$m, _b$k;
 class PgIntegerBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'number', 'PgInteger');
+    }
     /** @internal */
     build(table) {
         return new PgInteger(table, this.config);
@@ -3076,7 +3155,7 @@ function integer(name) {
 var _a$l, _b$j;
 class PgIntervalBuilder extends PgColumnBuilder {
     constructor(name, intervalConfig) {
-        super(name);
+        super(name, 'string', 'PgInterval');
         this.config.intervalConfig = intervalConfig;
     }
     /** @internal */
@@ -3106,6 +3185,9 @@ function interval(name, config = {}) {
 
 var _a$k, _b$i;
 class PgJsonBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'json', 'PgJson');
+    }
     /** @internal */
     build(table) {
         return new PgJson(table, this.config);
@@ -3143,6 +3225,9 @@ function json(name) {
 
 var _a$j, _b$h;
 class PgJsonbBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'json', 'PgJsonb');
+    }
     /** @internal */
     build(table) {
         return new PgJsonb(table, this.config);
@@ -3180,6 +3265,9 @@ function jsonb(name) {
 
 var _a$i, _b$g;
 class PgMacaddrBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'string', 'PgMacaddr');
+    }
     /** @internal */
     build(table) {
         return new PgMacaddr(table, this.config);
@@ -3200,6 +3288,9 @@ function macaddr(name) {
 
 var _a$h, _b$f;
 class PgMacaddr8Builder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'string', 'PgMacaddr8');
+    }
     /** @internal */
     build(table) {
         return new PgMacaddr8(table, this.config);
@@ -3221,7 +3312,7 @@ function macaddr8(name) {
 var _a$g, _b$e;
 class PgNumericBuilder extends PgColumnBuilder {
     constructor(name, precision, scale) {
-        super(name);
+        super(name, 'string', 'PgNumeric');
         this.config.precision = precision;
         this.config.scale = scale;
     }
@@ -3260,7 +3351,7 @@ const decimal = numeric;
 var _a$f, _b$d;
 class PgRealBuilder extends PgColumnBuilder {
     constructor(name, length) {
-        super(name);
+        super(name, 'number', 'PgReal');
         this.config.length = length;
     }
     /** @internal */
@@ -3293,7 +3384,7 @@ function real(name) {
 var _a$e, _b$c;
 class PgSerialBuilder extends PgColumnBuilder {
     constructor(name) {
-        super(name);
+        super(name, 'number', 'PgSerial');
         this.config.hasDefault = true;
         this.config.notNull = true;
     }
@@ -3317,6 +3408,9 @@ function serial(name) {
 
 var _a$d, _b$b;
 class PgSmallIntBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'number', 'PgSmallInt');
+    }
     /** @internal */
     build(table) {
         return new PgSmallInt(table, this.config);
@@ -3347,7 +3441,7 @@ function smallint(name) {
 var _a$c, _b$a;
 class PgSmallSerialBuilder extends PgColumnBuilder {
     constructor(name) {
-        super(name);
+        super(name, 'number', 'PgSmallSerial');
         this.config.hasDefault = true;
         this.config.notNull = true;
     }
@@ -3372,8 +3466,8 @@ function smallserial(name) {
 var _a$b, _b$9;
 class PgTextBuilder extends PgColumnBuilder {
     constructor(name, config) {
-        super(name);
-        this.config.enumValues = (config.enum ?? []);
+        super(name, 'string', 'PgText');
+        this.config.enumValues = config.enum;
     }
     /** @internal */
     build(table) {
@@ -3400,7 +3494,7 @@ function text(name, config = {}) {
 var _a$a, _b$8;
 class PgTimeBuilder extends PgDateColumnBaseBuilder {
     constructor(name, withTimezone, precision) {
-        super(name);
+        super(name, 'string', 'PgTime');
         this.withTimezone = withTimezone;
         this.precision = precision;
         this.config.withTimezone = withTimezone;
@@ -3433,7 +3527,7 @@ function time(name, config = {}) {
 var _a$9, _b$7, _c$4, _d$2;
 class PgTimestampBuilder extends PgDateColumnBaseBuilder {
     constructor(name, withTimezone, precision) {
-        super(name);
+        super(name, 'date', 'PgTimestamp');
         this.config.withTimezone = withTimezone;
         this.config.precision = precision;
     }
@@ -3465,7 +3559,7 @@ _b$7 = entityKind;
 PgTimestamp[_b$7] = 'PgTimestamp';
 class PgTimestampStringBuilder extends PgDateColumnBaseBuilder {
     constructor(name, withTimezone, precision) {
-        super(name);
+        super(name, 'string', 'PgTimestampString');
         this.config.withTimezone = withTimezone;
         this.config.precision = precision;
     }
@@ -3498,6 +3592,9 @@ function timestamp(name, config = {}) {
 
 var _a$8, _b$6;
 class PgUUIDBuilder extends PgColumnBuilder {
+    constructor(name) {
+        super(name, 'string', 'PgUUID');
+    }
     /**
      * Adds `default gen_random_uuid()` to the column definition.
      */
@@ -3525,9 +3622,9 @@ function uuid(name) {
 var _a$7, _b$5;
 class PgVarcharBuilder extends PgColumnBuilder {
     constructor(name, config) {
-        super(name);
+        super(name, 'string', 'PgVarchar');
         this.config.length = config.length;
-        this.config.enumValues = (config.enum ?? []);
+        this.config.enumValues = config.enum;
     }
     /** @internal */
     build(table) {
@@ -3850,17 +3947,21 @@ class Many extends Relation {
 }
 _d$1 = entityKind;
 Many[_d$1] = 'Many';
-const operators = {
-    sql,
-    eq,
-    and,
-    or,
-};
-const orderByOperators = {
-    sql,
-    asc,
-    desc,
-};
+function getOperators() {
+    return {
+        sql,
+        eq,
+        and,
+        or,
+    };
+}
+function getOrderByOperators() {
+    return {
+        sql,
+        asc,
+        desc,
+    };
+}
 function extractTablesRelationalConfig(schema, configHelpers) {
     if (Object.keys(schema).length === 1 && 'default' in schema && !is(schema['default'], Table)) {
         schema = schema['default'];
@@ -3946,8 +4047,8 @@ function normalizeRelation(schema, tableNamesMap, relation) {
     if (!referencedTableTsName) {
         throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
     }
-    const referencedTableFields = schema[referencedTableTsName];
-    if (!referencedTableFields) {
+    const referencedTableConfig = schema[referencedTableTsName];
+    if (!referencedTableConfig) {
         throw new Error(`Table "${referencedTableTsName}" not found in schema`);
     }
     const sourceTable = relation.sourceTable;
@@ -3956,7 +4057,7 @@ function normalizeRelation(schema, tableNamesMap, relation) {
         throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
     }
     const reverseRelations = [];
-    for (const referencedTableRelation of Object.values(referencedTableFields.relations)) {
+    for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) {
         if ((relation.relationName && relation !== referencedTableRelation
             && referencedTableRelation.relationName === relation.relationName)
             || (!relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable)) {
@@ -4020,31 +4121,57 @@ function bindIfParam(value, column) {
     }
     return value;
 }
-function eq(left, right) {
+/**
+ * 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)}`;
-}
-function ne(left, right) {
+};
+/**
+ * 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.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars not made by Ford
+ * db.select().from(cars)
+ *   .where(ne(cars.make, 'Ford'))
+ * ```
+ *
+ * @see isNotNull for a way to test whether a value is not null.
+ */
+const ne = (left, right) => {
     return sql `${left} <> ${bindIfParam(right, left)}`;
-}
+};
 function and(...unfilteredConditions) {
     const conditions = unfilteredConditions.filter((c) => c !== undefined);
     if (conditions.length === 0) {
         return undefined;
     }
     if (conditions.length === 1) {
-        return conditions[0];
+        return new SQL(conditions);
     }
-    const chunks = [sql.raw('(')];
-    for (const [index, condition] of conditions.entries()) {
-        if (index === 0) {
-            chunks.push(condition);
-        }
-        else {
-            chunks.push(sql ` and `, condition);
-        }
-    }
-    chunks.push(sql `)`);
-    return sql.join(chunks);
+    return new SQL([new StringChunk('('), sql.join(conditions, new StringChunk(' and ')), new StringChunk(')')]);
 }
 function or(...unfilteredConditions) {
     const conditions = unfilteredConditions.filter((c) => c !== undefined);
@@ -4052,19 +4179,9 @@ function or(...unfilteredConditions) {
         return undefined;
     }
     if (conditions.length === 1) {
-        return conditions[0];
-    }
-    const chunks = [sql.raw('(')];
-    for (const [index, condition] of conditions.entries()) {
-        if (index === 0) {
-            chunks.push(condition);
-        }
-        else {
-            chunks.push(sql ` or `, condition);
-        }
+        return new SQL(conditions);
     }
-    chunks.push(sql `)`);
-    return sql.join(chunks);
+    return new SQL([new StringChunk('('), sql.join(conditions, new StringChunk(' or ')), new StringChunk(')')]);
 }
 /**
  * Negate the meaning of an expression using the `not` keyword.
@@ -4080,18 +4197,76 @@ function or(...unfilteredConditions) {
 function not(condition) {
     return sql `not ${condition}`;
 }
-function gt(left, right) {
+/**
+ * Test that the first expression passed is greater than
+ * the second expression.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made after 2000.
+ * db.select().from(cars)
+ *   .where(gt(cars.year, 2000))
+ * ```
+ *
+ * @see gte for greater-than-or-equal
+ */
+const gt = (left, right) => {
     return sql `${left} > ${bindIfParam(right, left)}`;
-}
-function gte(left, right) {
+};
+/**
+ * Test that the first expression passed is greater than
+ * or equal to the second expression. Use `gt` to
+ * test whether an expression is strictly greater
+ * than another.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made on or after 2000.
+ * db.select().from(cars)
+ *   .where(gte(cars.year, 2000))
+ * ```
+ *
+ * @see gt for a strictly greater-than condition
+ */
+const gte = (left, right) => {
     return sql `${left} >= ${bindIfParam(right, left)}`;
-}
-function lt(left, right) {
+};
+/**
+ * Test that the first expression passed is less than
+ * the second expression.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made before 2000.
+ * db.select().from(cars)
+ *   .where(lt(cars.year, 2000))
+ * ```
+ *
+ * @see lte for greater-than-or-equal
+ */
+const lt = (left, right) => {
     return sql `${left} < ${bindIfParam(right, left)}`;
-}
-function lte(left, right) {
+};
+/**
+ * Test that the first expression passed is less than
+ * or equal to the second expression.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // Select cars made before 2000.
+ * db.select().from(cars)
+ *   .where(lte(cars.year, 2000))
+ * ```
+ *
+ * @see lt for a strictly less-than condition
+ */
+const lte = (left, right) => {
     return sql `${left} <= ${bindIfParam(right, left)}`;
-}
+};
 function inArray(column, values) {
     if (Array.isArray(values)) {
         if (values.length === 0) {
@@ -4129,8 +4304,8 @@ function notInArray(column, values) {
  *
  * @see isNotNull for the inverse of this test
  */
-function isNull(column) {
-    return sql `${column} is null`;
+function isNull(value) {
+    return sql `${value} is null`;
 }
 /**
  * Test whether an expression is not NULL. By the SQL standard,
@@ -4148,8 +4323,8 @@ function isNull(column) {
  *
  * @see isNull for the inverse of this test
  */
-function isNotNull(column) {
-    return sql `${column} is not null`;
+function isNotNull(value) {
+    return sql `${value} is not null`;
 }
 /**
  * Test whether a subquery evaluates to have any rows.
@@ -4359,6 +4534,9 @@ class StringChunk {
     constructor(value) {
         this.value = Array.isArray(value) ? value : [value];
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _b$1 = entityKind;
 StringChunk[_b$1] = 'StringChunk';
@@ -4453,6 +4631,9 @@ class SQL {
                 }
                 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: [] };
             }
@@ -4467,6 +4648,8 @@ class SQL {
                     new Name(chunk[SubqueryConfig].alias),
                 ], config);
             }
+            // if (is(chunk, Placeholder)) {
+            // 	return {sql: escapeParam}
             if (isSQLWrapper(chunk)) {
                 return this.buildQueryFromSourceParams([
                     new StringChunk('('),
@@ -4534,6 +4717,9 @@ class Name {
     constructor(value) {
         this.value = value;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _d = entityKind;
 Name[_d] = 'Name';
@@ -4568,6 +4754,9 @@ class Param {
         this.value = value;
         this.encoder = encoder;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _e = entityKind;
 Param[_e] = 'Param';
@@ -4675,6 +4864,9 @@ class Placeholder {
     constructor(name) {
         this.name = name;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _f = entityKind;
 Placeholder[_f] = 'Placeholder';
@@ -4692,6 +4884,10 @@ function fillPlaceholders(params, values) {
         return p;
     });
 }
+// Defined separately from the Column class to resolve circular dependency
+Column.prototype.getSQL = function () {
+    return new SQL([this]);
+};
 
 var _a, _b, _c;
 class ColumnAliasProxyHandler {
@@ -4920,6 +5116,9 @@ 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;
@@ -4953,6 +5152,8 @@ exports.extractTablesRelationalConfig = extractTablesRelationalConfig;
 exports.fillPlaceholders = fillPlaceholders;
 exports.foreignKey = foreignKey;
 exports.getMaterializedViewConfig = getMaterializedViewConfig;
+exports.getOperators = getOperators;
+exports.getOrderByOperators = getOrderByOperators;
 exports.getTableColumns = getTableColumns;
 exports.getTableConfig = getTableConfig;
 exports.getTableLikeName = getTableLikeName;
@@ -5002,9 +5203,7 @@ exports.notIlike = notIlike;
 exports.notInArray = notInArray;
 exports.notLike = notLike;
 exports.numeric = numeric;
-exports.operators = operators;
 exports.or = or;
-exports.orderByOperators = orderByOperators;
 exports.orderSelectedFields = orderSelectedFields;
 exports.param = param;
 exports.parsePgArray = parsePgArray;
@@ -5030,7 +5229,9 @@ exports.text = text;
 exports.time = time;
 exports.timestamp = timestamp;
 exports.tracer = tracer;
+exports.unique = unique;
 exports.uniqueIndex = uniqueIndex;
+exports.uniqueKeyName = uniqueKeyName;
 exports.uuid = uuid;
 exports.varchar = varchar;
-//# sourceMappingURL=alias-d10e3a09.cjs.map
+//# sourceMappingURL=alias-3f5ac719.cjs.map