drizzle-orm 0.27.3-e080bed → 0.28.0-5dd9190

package/{alias-5aeeb2f5.cjs → alias-3f5ac719.cjs}

@@ -34,6 +34,7 @@ var _a$V;
 class Column {
     constructor(table, config) {
         this.table = table;
+        this.enumValues = undefined;
         this.config = config;
         this.name = config.name;
         this.notNull = config.notNull;
@@ -43,6 +44,8 @@ class Column {
         this.isUnique = config.isUnique;
         this.uniqueName = config.uniqueName;
         this.uniqueType = config.uniqueType;
+        this.dataType = config.dataType;
+        this.columnType = config.columnType;
     }
     mapFromDriverValue(value) {
         return value;
@@ -81,6 +84,9 @@ class Table {
         this[Schema] = schema;
         this[BaseName] = baseName;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _a$U = entityKind, _b$K = IsAlias, _c$e = ExtraConfigBuilder, _d$7 = IsDrizzleTable;
 Table[_a$U] = 'Table';
@@ -183,6 +189,9 @@ class View {
             isAlias: false,
         };
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _a$R = entityKind;
 View[_a$R] = 'View';
@@ -412,6 +421,9 @@ class Subquery {
             isWith,
         };
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _a$M = entityKind;
 Subquery[_a$M] = 'Subquery';
@@ -991,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 = [];
@@ -1555,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 = [];
@@ -1602,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({
@@ -1624,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];
@@ -1650,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,
@@ -1677,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
@@ -1697,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),
@@ -1733,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,
@@ -2634,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() {
@@ -2685,7 +2666,7 @@ class PgColumnBuilder extends ColumnBuilder {
     /** @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] };
@@ -2697,7 +2678,7 @@ class PgColumnBuilder extends ColumnBuilder {
                     builder.onDelete(actions.onDelete);
                 }
                 return builder.build(table);
-            })(ref, actions);
+            }, ref, actions);
         });
     }
 }
@@ -2719,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;
     }
@@ -2764,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);
@@ -2785,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);
@@ -2813,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;
     }
@@ -2839,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 */
@@ -2869,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);
@@ -2890,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) {
@@ -2919,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);
@@ -2940,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;
     }
@@ -2990,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);
@@ -3011,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);
@@ -3034,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);
@@ -3061,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 */
@@ -3100,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);
@@ -3120,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);
@@ -3147,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 */
@@ -3177,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);
@@ -3214,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);
@@ -3251,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);
@@ -3271,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);
@@ -3292,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;
     }
@@ -3331,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 */
@@ -3364,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;
     }
@@ -3388,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);
@@ -3418,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;
     }
@@ -3443,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) {
@@ -3471,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;
@@ -3504,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;
     }
@@ -3536,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;
     }
@@ -3569,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.
      */
@@ -3596,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) {
@@ -3921,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'];
@@ -4017,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;
@@ -4027,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)) {
@@ -4091,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];
-    }
-    const chunks = [sql.raw('(')];
-    for (const [index, condition] of conditions.entries()) {
-        if (index === 0) {
-            chunks.push(condition);
-        }
-        else {
-            chunks.push(sql ` and `, condition);
-        }
+        return new SQL(conditions);
     }
-    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);
@@ -4123,19 +4179,9 @@ function or(...unfilteredConditions) {
         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 ` or `, condition);
-        }
-    }
-    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.
@@ -4151,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) {
@@ -4200,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,
@@ -4219,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.
@@ -4430,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';
@@ -4524,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: [] };
             }
@@ -4538,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('('),
@@ -4605,6 +4717,9 @@ class Name {
     constructor(value) {
         this.value = value;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _d = entityKind;
 Name[_d] = 'Name';
@@ -4639,6 +4754,9 @@ class Param {
         this.value = value;
         this.encoder = encoder;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _e = entityKind;
 Param[_e] = 'Param';
@@ -4746,6 +4864,9 @@ class Placeholder {
     constructor(name) {
         this.name = name;
     }
+    getSQL() {
+        return new SQL([this]);
+    }
 }
 _f = entityKind;
 Placeholder[_f] = 'Placeholder';
@@ -4763,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 {
@@ -5027,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;
@@ -5076,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;
@@ -5109,4 +5234,4 @@ exports.uniqueIndex = uniqueIndex;
 exports.uniqueKeyName = uniqueKeyName;
 exports.uuid = uuid;
 exports.varchar = varchar;
-//# sourceMappingURL=alias-5aeeb2f5.cjs.map
+//# sourceMappingURL=alias-3f5ac719.cjs.map