drizzle-orm 0.26.1 → 0.26.2-83ca12d

package/{relations-c9e54a8f.mjs → relations-d3070559.mjs}

@@ -1,9 +1,18 @@
+import { v as version } from './package-1b949c2d.mjs';
+
 /*
     `Column` only accepts a full `ColumnConfig` as its generic.
     To infer parts of the config, use `AnyColumn` that accepts a partial config.
     See `GetColumnData` for example usage of inferring.
 */
 class Column {
+    table;
+    name;
+    primary;
+    notNull;
+    default;
+    hasDefault;
+    config;
     constructor(table, config) {
         this.table = table;
         this.config = config;
@@ -23,6 +32,8 @@ class Column {
 
 const ViewBaseConfig = Symbol('ViewBaseConfig');
 class View {
+    /** @internal */
+    [ViewBaseConfig];
     constructor({ name, schema, selectedFields, query }) {
         this[ViewBaseConfig] = {
             name,
@@ -38,6 +49,8 @@ class View {
 
 const SubqueryConfig = Symbol('SubqueryConfig');
 class Subquery {
+    /** @internal */
+    [SubqueryConfig];
     constructor(sql, selection, alias, isWith = false) {
         this[SubqueryConfig] = {
             sql,
@@ -50,6 +63,7 @@ class Subquery {
 class WithSubquery extends Subquery {
 }
 class SelectionProxyHandler {
+    config;
     constructor(config) {
         this.config = { ...config };
     }
@@ -103,7 +117,6 @@ class SelectionProxyHandler {
     }
 }
 
-var _a$2, _b$1, _c;
 /** @internal */
 const TableName = Symbol('Name');
 /** @internal */
@@ -120,28 +133,46 @@ const IsAlias = Symbol('IsAlias');
 const ExtraConfigBuilder = Symbol('ExtraConfigBuilder');
 const IsDrizzleTable = Symbol.for('IsDrizzleTable');
 class 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) {
-        /** @internal */
-        this[_a$2] = false;
-        /** @internal */
-        this[_b$1] = undefined;
-        this[_c] = true;
         this[TableName] = this[OriginalName] = name;
         this[Schema] = schema;
         this[BaseName] = baseName;
     }
 }
-_a$2 = IsAlias, _b$1 = ExtraConfigBuilder, _c = IsDrizzleTable;
-/** @internal */
-Table.Symbol = {
-    Name: TableName,
-    Schema: Schema,
-    OriginalName: OriginalName,
-    Columns: Columns,
-    BaseName: BaseName,
-    IsAlias: IsAlias,
-    ExtraConfigBuilder: ExtraConfigBuilder,
-};
 function isTable(table) {
     return typeof table === 'object' && table !== null && IsDrizzleTable in table;
 }
@@ -149,6 +180,158 @@ function getTableName(table) {
     return table[TableName];
 }
 
+/** @internal */
+function mapResultRow(columns, row, joinsNotNullableMap) {
+    // Key -> nested object key, value -> table name if all fields in the nested object are from the same table, false otherwise
+    const nullifyMap = {};
+    const result = columns.reduce((result, { path, field }, columnIndex) => {
+        let decoder;
+        if (field instanceof Column) {
+            decoder = field;
+        }
+        else if (field instanceof SQL) {
+            decoder = field.decoder;
+        }
+        else {
+            decoder = field.sql.decoder;
+        }
+        let node = result;
+        for (const [pathChunkIndex, pathChunk] of path.entries()) {
+            if (pathChunkIndex < path.length - 1) {
+                if (!(pathChunk in node)) {
+                    node[pathChunk] = {};
+                }
+                node = node[pathChunk];
+            }
+            else {
+                const rawValue = row[columnIndex];
+                const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+                if (joinsNotNullableMap && field instanceof Column && path.length === 2) {
+                    const objectName = path[0];
+                    if (!(objectName in nullifyMap)) {
+                        nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+                    }
+                    else if (typeof nullifyMap[objectName] === 'string' && nullifyMap[objectName] !== getTableName(field.table)) {
+                        nullifyMap[objectName] = false;
+                    }
+                }
+            }
+        }
+        return result;
+    }, {});
+    // Nullify all nested objects from nullifyMap that are nullable
+    if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+        for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+            if (typeof tableName === 'string' && !joinsNotNullableMap[tableName]) {
+                result[objectName] = null;
+            }
+        }
+    }
+    return result;
+}
+/** @internal */
+function orderSelectedFields(fields, pathPrefix) {
+    return Object.entries(fields).reduce((result, [name, field]) => {
+        if (typeof name !== 'string') {
+            return result;
+        }
+        const newPath = pathPrefix ? [...pathPrefix, name] : [name];
+        if (field instanceof Column
+            || field instanceof SQL
+            || field instanceof SQL.Aliased) {
+            result.push({ path: newPath, field });
+        }
+        else if (field instanceof Table) {
+            result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
+        }
+        else {
+            result.push(...orderSelectedFields(field, newPath));
+        }
+        return result;
+    }, []);
+}
+/** @internal */
+function mapUpdateSet(table, values) {
+    const entries = Object.entries(values)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => {
+        // eslint-disable-next-line unicorn/prefer-ternary
+        if (value instanceof SQL) {
+            return [key, value];
+        }
+        else {
+            return [key, new Param(value, table[Table.Symbol.Columns][key])];
+        }
+    });
+    if (entries.length === 0) {
+        throw new Error('No values to set');
+    }
+    return Object.fromEntries(entries);
+}
+/** @internal */
+function applyMixins(baseClass, extendedClasses) {
+    for (const extendedClass of extendedClasses) {
+        for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
+            Object.defineProperty(baseClass.prototype, name, Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || Object.create(null));
+        }
+    }
+}
+function getTableColumns(table) {
+    return table[Table.Symbol.Columns];
+}
+/** @internal */
+function getTableLikeName(table) {
+    return table instanceof Subquery
+        ? table[SubqueryConfig].alias
+        : table instanceof View
+            ? table[ViewBaseConfig].name
+            : table instanceof SQL
+                ? undefined
+                : table[Table.Symbol.IsAlias]
+                    ? table[Table.Symbol.Name]
+                    : table[Table.Symbol.BaseName];
+}
+function iife(fn, ...args) {
+    return fn(...args);
+}
+
+let otel;
+let rawTracer;
+try {
+    otel = await import('@opentelemetry/api');
+}
+catch (err) {
+    if (err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+        throw err;
+    }
+}
+/** @internal */
+const tracer = {
+    startActiveSpan(name, fn) {
+        if (!otel) {
+            return fn();
+        }
+        if (!rawTracer) {
+            rawTracer = otel.trace.getTracer('drizzle-orm', version);
+        }
+        return iife((otel, rawTracer) => rawTracer.startActiveSpan(name, ((span) => {
+            try {
+                return fn(span);
+            }
+            catch (e) {
+                span.setStatus({
+                    code: otel.SpanStatusCode.ERROR,
+                    message: e instanceof Error ? e.message : 'Unknown error',
+                });
+                throw e;
+            }
+            finally {
+                span.end();
+            }
+        })), otel, rawTracer);
+    },
+};
+
 function bindIfParam(value, column) {
     if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !(value instanceof Param) && !(value instanceof Placeholder)
         && !(value instanceof Column) && !(value instanceof Table) && !(value instanceof View)) {
@@ -332,7 +515,7 @@ function exists(subquery) {
  * @see exists for the inverse of this test
  */
 function notExists(subquery) {
-    return sql `exists (${subquery})`;
+    return sql `not exists (${subquery})`;
 }
 function between(column, min, max) {
     return sql `${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
@@ -481,30 +664,40 @@ function mergeQueries(queries) {
     for (const query of queries) {
         result.sql += query.sql;
         result.params.push(...query.params);
-        if (result.typings && query.typings?.length) {
+        if (query.typings?.length) {
+            result.typings = result.typings || [];
             result.typings.push(...query.typings);
         }
     }
     return result;
 }
 class StringChunk {
+    value;
     constructor(value) {
         this.value = Array.isArray(value) ? value : [value];
     }
 }
 class SQL {
+    queryChunks;
+    /** @internal */
+    decoder = noopDecoder;
+    shouldInlineParams = false;
     constructor(queryChunks) {
         this.queryChunks = queryChunks;
-        /** @internal */
-        this.decoder = noopDecoder;
-        this.shouldInlineParams = false;
     }
     append(query) {
         this.queryChunks.push(...query.queryChunks);
         return this;
     }
     toQuery(config) {
-        return this.buildQueryFromSourceParams(this.queryChunks, 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, {
@@ -652,6 +845,8 @@ class SQL {
  * Any DB name (table, column, index etc.)
  */
 class Name {
+    value;
+    brand;
     constructor(value) {
         this.value = value;
     }
@@ -679,6 +874,9 @@ const noopMapper = {
 };
 /** Parameter value that is optionally bound to an encoder (for example, a column). */
 class Param {
+    value;
+    encoder;
+    brand;
     /**
      * @param value - Parameter value
      * @param encoder - Encoder to convert the value to a driver parameter
@@ -749,11 +947,13 @@ function sql(strings, ...params) {
 })(sql || (sql = {}));
 (function (SQL) {
     class Aliased {
+        sql;
+        fieldAlias;
+        /** @internal */
+        isSelectionField = false;
         constructor(sql, fieldAlias) {
             this.sql = sql;
             this.fieldAlias = fieldAlias;
-            /** @internal */
-            this.isSelectionField = false;
         }
         getSQL() {
             return this.sql;
@@ -766,6 +966,7 @@ function sql(strings, ...params) {
     SQL.Aliased = Aliased;
 })(SQL || (SQL = {}));
 class Placeholder {
+    name;
     constructor(name) {
         this.name = name;
     }
@@ -786,6 +987,7 @@ function fillPlaceholders(params, values) {
 }
 
 class ColumnAliasProxyHandler {
+    table;
     constructor(table) {
         this.table = table;
     }
@@ -797,6 +999,8 @@ class ColumnAliasProxyHandler {
     }
 }
 class TableAliasProxyHandler {
+    alias;
+    replaceOriginalName;
     constructor(alias, replaceOriginalName) {
         this.alias = alias;
         this.replaceOriginalName = replaceOriginalName;
@@ -837,6 +1041,7 @@ class TableAliasProxyHandler {
     }
 }
 class RelationTableAliasProxyHandler {
+    alias;
     constructor(alias) {
         this.alias = alias;
     }
@@ -876,6 +1081,7 @@ function mapColumnsInSQLToAlias(query, alias) {
 
 // To understand how to use `ColumnBuilder` and `AnyColumnBuilder`, see `Column` and `AnyColumn` documentation.
 class ColumnBuilder {
+    config;
     constructor(name) {
         this.config = {
             name,
@@ -903,11 +1109,8 @@ class ColumnBuilder {
     }
 }
 
-var _a$1;
 class QueryPromise {
-    constructor() {
-        this[_a$1] = 'QueryPromise';
-    }
+    [Symbol.toStringTag] = 'QueryPromise';
     catch(onRejected) {
         return this.then(undefined, onRejected);
     }
@@ -924,9 +1127,11 @@ class QueryPromise {
         return this.execute().then(onFulfilled, onRejected);
     }
 }
-_a$1 = Symbol.toStringTag;
 
 class CheckBuilder {
+    name;
+    value;
+    brand;
     constructor(name, value) {
         this.name = name;
         this.value = value;
@@ -937,6 +1142,9 @@ class CheckBuilder {
     }
 }
 class Check {
+    table;
+    name;
+    value;
     constructor(table, builder) {
         this.table = table;
         this.name = builder.name;
@@ -947,23 +1155,18 @@ function check(name, value) {
     return new CheckBuilder(name, value);
 }
 
-var _a, _b;
 /** @internal */
 const InlineForeignKeys = Symbol('InlineForeignKeys');
 class PgTable extends Table {
-    constructor() {
-        super(...arguments);
-        /**@internal */
-        this[_a] = [];
-        /** @internal */
-        this[_b] = undefined;
-    }
+    /** @internal */
+    static Symbol = Object.assign({}, Table.Symbol, {
+        InlineForeignKeys: InlineForeignKeys,
+    });
+    /**@internal */
+    [InlineForeignKeys] = [];
+    /** @internal */
+    [Table.Symbol.ExtraConfigBuilder] = undefined;
 }
-_a = InlineForeignKeys, _b = Table.Symbol.ExtraConfigBuilder;
-/** @internal */
-PgTable.Symbol = Object.assign({}, Table.Symbol, {
-    InlineForeignKeys: InlineForeignKeys,
-});
 /** @internal */
 function pgTableWithSchema(name, columns, extraConfig, schema, baseName = name) {
     const rawTable = new PgTable(name, schema, baseName);
@@ -989,11 +1192,13 @@ function pgTableCreator(customizeTableName) {
 }
 
 class ForeignKeyBuilder {
+    /** @internal */
+    reference;
+    /** @internal */
+    _onUpdate = 'no action';
+    /** @internal */
+    _onDelete = 'no action';
     constructor(config, actions) {
-        /** @internal */
-        this._onUpdate = 'no action';
-        /** @internal */
-        this._onDelete = 'no action';
         this.reference = () => {
             const { columns, foreignColumns } = config();
             return { columns, foreignTable: foreignColumns[0].table, foreignColumns };
@@ -1017,6 +1222,10 @@ class ForeignKeyBuilder {
     }
 }
 class ForeignKey {
+    table;
+    reference;
+    onUpdate;
+    onDelete;
     constructor(table, builder) {
         this.table = table;
         this.reference = builder.reference;
@@ -1048,6 +1257,8 @@ function foreignKey(config) {
 }
 
 class IndexBuilderOn {
+    unique;
+    name;
     constructor(unique, name) {
         this.unique = unique;
         this.name = name;
@@ -1060,6 +1271,8 @@ class IndexBuilderOn {
     }
 }
 class IndexBuilder {
+    /** @internal */
+    config;
     constructor(columns, unique, only, name) {
         this.config = {
             name,
@@ -1102,6 +1315,7 @@ class IndexBuilder {
     }
 }
 class Index {
+    config;
     constructor(config, table) {
         this.config = { ...config, table };
     }
@@ -1117,6 +1331,8 @@ function primaryKey(...columns) {
     return new PrimaryKeyBuilder(columns);
 }
 class PrimaryKeyBuilder {
+    /** @internal */
+    columns;
     constructor(columns) {
         this.columns = columns;
     }
@@ -1126,6 +1342,8 @@ class PrimaryKeyBuilder {
     }
 }
 class PrimaryKey {
+    table;
+    columns;
     constructor(table, columns) {
         this.table = table;
         this.columns = columns;
@@ -1135,118 +1353,6 @@ class PrimaryKey {
     }
 }
 
-/** @internal */
-function mapResultRow(columns, row, joinsNotNullableMap) {
-    // Key -> nested object key, value -> table name if all fields in the nested object are from the same table, false otherwise
-    const nullifyMap = {};
-    const result = columns.reduce((result, { path, field }, columnIndex) => {
-        let decoder;
-        if (field instanceof Column) {
-            decoder = field;
-        }
-        else if (field instanceof SQL) {
-            decoder = field.decoder;
-        }
-        else {
-            decoder = field.sql.decoder;
-        }
-        let node = result;
-        for (const [pathChunkIndex, pathChunk] of path.entries()) {
-            if (pathChunkIndex < path.length - 1) {
-                if (!(pathChunk in node)) {
-                    node[pathChunk] = {};
-                }
-                node = node[pathChunk];
-            }
-            else {
-                const rawValue = row[columnIndex];
-                const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-                if (joinsNotNullableMap && field instanceof Column && path.length === 2) {
-                    const objectName = path[0];
-                    if (!(objectName in nullifyMap)) {
-                        nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
-                    }
-                    else if (typeof nullifyMap[objectName] === 'string' && nullifyMap[objectName] !== getTableName(field.table)) {
-                        nullifyMap[objectName] = false;
-                    }
-                }
-            }
-        }
-        return result;
-    }, {});
-    // Nullify all nested objects from nullifyMap that are nullable
-    if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
-        for (const [objectName, tableName] of Object.entries(nullifyMap)) {
-            if (typeof tableName === 'string' && !joinsNotNullableMap[tableName]) {
-                result[objectName] = null;
-            }
-        }
-    }
-    return result;
-}
-/** @internal */
-function orderSelectedFields(fields, pathPrefix) {
-    return Object.entries(fields).reduce((result, [name, field]) => {
-        if (typeof name !== 'string') {
-            return result;
-        }
-        const newPath = pathPrefix ? [...pathPrefix, name] : [name];
-        if (field instanceof Column
-            || field instanceof SQL
-            || field instanceof SQL.Aliased) {
-            result.push({ path: newPath, field });
-        }
-        else if (field instanceof Table) {
-            result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
-        }
-        else {
-            result.push(...orderSelectedFields(field, newPath));
-        }
-        return result;
-    }, []);
-}
-/** @internal */
-function mapUpdateSet(table, values) {
-    const entries = Object.entries(values)
-        .filter(([, value]) => value !== undefined)
-        .map(([key, value]) => {
-        // eslint-disable-next-line unicorn/prefer-ternary
-        if (value instanceof SQL) {
-            return [key, value];
-        }
-        else {
-            return [key, new Param(value, table[Table.Symbol.Columns][key])];
-        }
-    });
-    if (entries.length === 0) {
-        throw new Error('No values to set');
-    }
-    return Object.fromEntries(entries);
-}
-/** @internal */
-function applyMixins(baseClass, extendedClasses) {
-    for (const extendedClass of extendedClasses) {
-        for (const name of Object.getOwnPropertyNames(extendedClass.prototype)) {
-            Object.defineProperty(baseClass.prototype, name, Object.getOwnPropertyDescriptor(extendedClass.prototype, name) || Object.create(null));
-        }
-    }
-}
-function getTableColumns(table) {
-    return table[Table.Symbol.Columns];
-}
-/** @internal */
-function getTableLikeName(table) {
-    return table instanceof Subquery
-        ? table[SubqueryConfig].alias
-        : table instanceof View
-            ? table[ViewBaseConfig].name
-            : table instanceof SQL
-                ? undefined
-                : table[Table.Symbol.IsAlias]
-                    ? table[Table.Symbol.Name]
-                    : table[Table.Symbol.BaseName];
-}
-
 class PgDialect {
     async migrate(migrations, session) {
         const migrationTableCreate = sql `
@@ -1799,6 +1905,10 @@ class TypedQueryBuilder {
 }
 
 class PgSelectBuilder {
+    fields;
+    session;
+    dialect;
+    withList;
     constructor(fields, session, dialect, withList = []) {
         this.fields = fields;
         this.session = session;
@@ -1834,40 +1944,18 @@ class PgSelectBuilder {
     }
 }
 class PgSelectQueryBuilder extends TypedQueryBuilder {
+    isPartialSelect;
+    session;
+    dialect;
+    _;
+    config;
+    joinsNotNullableMap;
+    tableName;
     constructor(table, fields, isPartialSelect, session, dialect, withList) {
         super();
         this.isPartialSelect = isPartialSelect;
         this.session = session;
         this.dialect = dialect;
-        /**
-         * For each row of the table, include
-         * values from a matching row of the joined
-         * table, if there is a matching row. If not,
-         * all of the columns of the joined table
-         * will be set to null.
-         */
-        this.leftJoin = this.createJoin('left');
-        /**
-         * Includes all of the rows of the joined table.
-         * If there is no matching row in the main table,
-         * all the columns of the main table will be
-         * set to null.
-         */
-        this.rightJoin = this.createJoin('right');
-        /**
-         * This is the default type of join.
-         *
-         * For each row of the table, the joined table
-         * needs to have a matching row, or it will
-         * be excluded from results.
-         */
-        this.innerJoin = this.createJoin('inner');
-        /**
-         * Rows from both the main & joined are included,
-         * regardless of whether or not they have matching
-         * rows in the other table.
-         */
-        this.fullJoin = this.createJoin('full');
         this.config = {
             withList,
             table,
@@ -1935,6 +2023,35 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
             return this;
         };
     }
+    /**
+     * For each row of the table, include
+     * values from a matching row of the joined
+     * table, if there is a matching row. If not,
+     * all of the columns of the joined table
+     * will be set to null.
+     */
+    leftJoin = this.createJoin('left');
+    /**
+     * Includes all of the rows of the joined table.
+     * If there is no matching row in the main table,
+     * all the columns of the main table will be
+     * set to null.
+     */
+    rightJoin = this.createJoin('right');
+    /**
+     * This is the default type of join.
+     *
+     * For each row of the table, the joined table
+     * needs to have a matching row, or it will
+     * be excluded from results.
+     */
+    innerJoin = this.createJoin('inner');
+    /**
+     * Rows from both the main & joined are included,
+     * regardless of whether or not they have matching
+     * rows in the other table.
+     */
+    fullJoin = this.createJoin('full');
     /**
      * Specify a condition to narrow the result set. Multiple
      * conditions can be combined with the `and` and `or`
@@ -2044,20 +2161,17 @@ class PgSelectQueryBuilder extends TypedQueryBuilder {
     }
 }
 class PgSelect extends PgSelectQueryBuilder {
-    constructor() {
-        super(...arguments);
-        this.execute = (placeholderValues) => {
-            return this._prepare().execute(placeholderValues);
-        };
-    }
     _prepare(name) {
-        if (!this.session) {
+        const { session, config, dialect, joinsNotNullableMap } = this;
+        if (!session) {
             throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
         }
-        const fieldsList = orderSelectedFields(this.config.fields);
-        const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), fieldsList, name);
-        query.joinsNotNullableMap = this.joinsNotNullableMap;
-        return query;
+        return tracer.startActiveSpan('drizzle.prepareQuery', () => {
+            const fieldsList = orderSelectedFields(config.fields);
+            const query = session.prepareQuery(dialect.sqlToQuery(this.getSQL()), fieldsList, name);
+            query.joinsNotNullableMap = joinsNotNullableMap;
+            return query;
+        });
     }
     /**
      * Create a prepared statement for this query. This allows
@@ -2069,10 +2183,16 @@ class PgSelect extends PgSelectQueryBuilder {
     prepare(name) {
         return this._prepare(name);
     }
+    execute = (placeholderValues) => {
+        return tracer.startActiveSpan('drizzle.operation', () => {
+            return this._prepare().execute(placeholderValues);
+        });
+    };
 }
 applyMixins(PgSelect, [QueryPromise]);
 
 class QueryBuilder {
+    dialect;
     $with(alias) {
         const queryBuilder = this;
         return {
@@ -2104,11 +2224,13 @@ class QueryBuilder {
 }
 
 class DefaultViewBuilderCore {
+    name;
+    schema;
     constructor(name, schema) {
         this.name = name;
         this.schema = schema;
-        this.config = {};
     }
+    config = {};
     with(config) {
         this.config.with = config;
         return this;
@@ -2138,6 +2260,7 @@ class ViewBuilder extends DefaultViewBuilderCore {
     }
 }
 class ManualViewBuilder extends DefaultViewBuilderCore {
+    columns;
     constructor(name, columns, schema) {
         super(name, schema);
         this.columns = getTableColumns(pgTable(name, columns));
@@ -2176,11 +2299,13 @@ class ManualViewBuilder extends DefaultViewBuilderCore {
     }
 }
 class MaterializedViewBuilderCore {
+    name;
+    schema;
     constructor(name, schema) {
         this.name = name;
         this.schema = schema;
-        this.config = {};
     }
+    config = {};
     using(using) {
         this.config.using = using;
         return this;
@@ -2227,6 +2352,7 @@ class MaterializedViewBuilder extends MaterializedViewBuilderCore {
     }
 }
 class ManualMaterializedViewBuilder extends MaterializedViewBuilderCore {
+    columns;
     constructor(name, columns, schema) {
         super(name, schema);
         this.columns = getTableColumns(pgTable(name, columns));
@@ -2268,6 +2394,7 @@ class PgViewBase extends View {
 }
 const PgViewConfig = Symbol('PgViewConfig');
 class PgView extends PgViewBase {
+    [PgViewConfig];
     constructor({ pgConfig, config }) {
         super(config);
         if (pgConfig) {
@@ -2279,6 +2406,7 @@ class PgView extends PgViewBase {
 }
 const PgMaterializedViewConfig = Symbol('PgMaterializedViewConfig');
 class PgMaterializedView extends PgViewBase {
+    [PgMaterializedViewConfig];
     constructor({ pgConfig, config }) {
         super(config);
         this[PgMaterializedViewConfig] = {
@@ -2434,10 +2562,7 @@ function makePgArray(array) {
 }
 
 class PgColumnBuilder extends ColumnBuilder {
-    constructor() {
-        super(...arguments);
-        this.foreignKeyConfigs = [];
-    }
+    foreignKeyConfigs = [];
     array(size) {
         return new PgArrayBuilder(this.config.name, this, size);
     }
@@ -2481,6 +2606,9 @@ class PgArrayBuilder extends PgColumnBuilder {
     }
 }
 class PgArray extends PgColumn {
+    baseColumn;
+    range;
+    size;
     constructor(table, config, baseColumn, range) {
         super(table, config);
         this.baseColumn = baseColumn;
@@ -2626,6 +2754,8 @@ class PgNumericBuilder extends PgColumnBuilder {
     }
 }
 class PgNumeric extends PgColumn {
+    precision;
+    scale;
     constructor(table, config) {
         super(table, config);
         this.precision = config.precision;
@@ -2649,6 +2779,8 @@ function numeric(name, config) {
 const decimal = numeric;
 
 class PgTimeBuilder extends PgDateColumnBaseBuilder {
+    withTimezone;
+    precision;
     constructor(name, withTimezone, precision) {
         super(name);
         this.withTimezone = withTimezone;
@@ -2662,6 +2794,8 @@ class PgTimeBuilder extends PgDateColumnBaseBuilder {
     }
 }
 class PgTime extends PgColumn {
+    withTimezone;
+    precision;
     constructor(table, config) {
         super(table, config);
         this.withTimezone = config.withTimezone;
@@ -2688,14 +2822,10 @@ class PgTimestampBuilder extends PgDateColumnBaseBuilder {
     }
 }
 class PgTimestamp extends PgColumn {
+    withTimezone;
+    precision;
     constructor(table, config) {
         super(table, config);
-        this.mapFromDriverValue = (value) => {
-            return new Date(this.withTimezone ? value : value + '+0000');
-        };
-        this.mapToDriverValue = (value) => {
-            return this.withTimezone ? value.toUTCString() : value.toISOString();
-        };
         this.withTimezone = config.withTimezone;
         this.precision = config.precision;
     }
@@ -2703,6 +2833,12 @@ class PgTimestamp extends PgColumn {
         const precision = this.precision === undefined ? '' : ` (${this.precision})`;
         return `timestamp${precision}${this.withTimezone ? ' with time zone' : ''}`;
     }
+    mapFromDriverValue = (value) => {
+        return new Date(this.withTimezone ? value : value + '+0000');
+    };
+    mapToDriverValue = (value) => {
+        return this.withTimezone ? value.toUTCString() : value.toISOString();
+    };
 }
 class PgTimestampStringBuilder extends PgDateColumnBaseBuilder {
     constructor(name, withTimezone, precision) {
@@ -2716,6 +2852,8 @@ class PgTimestampStringBuilder extends PgDateColumnBaseBuilder {
     }
 }
 class PgTimestampString extends PgColumn {
+    withTimezone;
+    precision;
     constructor(table, config) {
         super(table, config);
         this.withTimezone = config.withTimezone;
@@ -2755,6 +2893,11 @@ function uuid(name) {
 }
 
 class Relation {
+    sourceTable;
+    referencedTable;
+    relationName;
+    referencedTableName;
+    fieldName;
     constructor(sourceTable, referencedTable, relationName) {
         this.sourceTable = sourceTable;
         this.referencedTable = referencedTable;
@@ -2763,12 +2906,16 @@ class Relation {
     }
 }
 class Relations {
+    table;
+    config;
     constructor(table, config) {
         this.table = table;
         this.config = config;
     }
 }
 class One extends Relation {
+    config;
+    isNullable;
     constructor(sourceTable, referencedTable, config, isNullable) {
         super(sourceTable, referencedTable, config?.relationName);
         this.config = config;
@@ -2781,6 +2928,7 @@ class One extends Relation {
     }
 }
 class Many extends Relation {
+    config;
     constructor(sourceTable, referencedTable, config) {
         super(sourceTable, referencedTable, config?.relationName);
         this.config = config;
@@ -2959,5 +3107,5 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
     return result;
 }
 
-export { name as $, notLike as A, ilike as B, ColumnAliasProxyHandler as C, notIlike as D, asc as E, desc as F, Relation as G, Relations as H, operators as I, orderByOperators as J, extractTablesRelationalConfig as K, relations as L, Many as M, createOne as N, One as O, createMany as P, QueryPromise as Q, RelationTableAliasProxyHandler as R, normalizeRelation as S, TableAliasProxyHandler as T, createTableRelationsHelpers as U, mapRelationalRow as V, FakePrimitiveParam as W, isSQLWrapper as X, StringChunk as Y, SQL as Z, Name as _, aliasedTable as a, PgTimestampStringBuilder as a$, isDriverValueEncoder as a0, noopDecoder as a1, noopEncoder as a2, noopMapper as a3, Param as a4, param as a5, sql as a6, Placeholder as a7, placeholder as a8, fillPlaceholders as a9, pgViewWithSchema as aA, pgMaterializedViewWithSchema as aB, CheckBuilder as aC, Check as aD, check as aE, PgArrayBuilder as aF, PgArray as aG, PgDateBuilder as aH, PgDate as aI, PgDateStringBuilder as aJ, PgDateString as aK, date as aL, PgJsonBuilder as aM, PgJson as aN, json as aO, PgJsonbBuilder as aP, PgJsonb as aQ, jsonb as aR, PgNumericBuilder as aS, PgNumeric as aT, numeric as aU, decimal as aV, PgTimeBuilder as aW, PgTime as aX, time as aY, PgTimestampBuilder as aZ, PgTimestamp as a_, SubqueryConfig as aa, Subquery as ab, WithSubquery as ac, SelectionProxyHandler as ad, TableName as ae, Schema as af, Columns as ag, OriginalName as ah, BaseName as ai, IsAlias as aj, ExtraConfigBuilder as ak, Table as al, isTable as am, getTableName as an, mapResultRow as ao, orderSelectedFields as ap, mapUpdateSet as aq, applyMixins as ar, getTableColumns as as, getTableLikeName as at, ViewBaseConfig as au, View as av, PgDialect as aw, PgColumnBuilder as ax, PgColumn as ay, pgTableWithSchema as az, aliasedRelation as b, PgTimestampString as b0, timestamp as b1, PgUUIDBuilder as b2, PgUUID as b3, uuid as b4, ForeignKeyBuilder as b5, ForeignKey as b6, foreignKey as b7, IndexBuilderOn as b8, IndexBuilder as b9, PgViewBase as bA, PgViewConfig as bB, PgView as bC, PgMaterializedViewConfig as bD, PgMaterializedView as bE, pgView as bF, pgMaterializedView as bG, TypedQueryBuilder as bH, Index as ba, index as bb, uniqueIndex as bc, primaryKey as bd, PrimaryKeyBuilder as be, PrimaryKey as bf, QueryBuilder as bg, PgSelectBuilder as bh, PgSelectQueryBuilder as bi, PgSelect as bj, InlineForeignKeys as bk, PgTable as bl, pgTable as bm, pgTableCreator as bn, getTableConfig as bo, getViewConfig as bp, getMaterializedViewConfig as bq, parsePgNestedArray as br, parsePgArray as bs, makePgArray as bt, DefaultViewBuilderCore as bu, ViewBuilder as bv, ManualViewBuilder as bw, MaterializedViewBuilderCore as bx, MaterializedViewBuilder as by, ManualMaterializedViewBuilder as bz, aliasedTableColumn as c, mapColumnsInSQLToAlias as d, Column as e, ColumnBuilder as f, bindIfParam as g, eq as h, and as i, not as j, gt as k, gte as l, mapColumnsInAliasedSQLToAlias as m, ne as n, or as o, lt as p, lte as q, inArray as r, notInArray as s, isNull as t, isNotNull as u, exists as v, notExists as w, between as x, notBetween as y, like as z };
-//# sourceMappingURL=relations-c9e54a8f.mjs.map
+export { PgArray as $, normalizeRelation as A, and as B, Column as C, or as D, aliasedTable as E, eq as F, TypedQueryBuilder as G, getTableLikeName as H, applyMixins as I, ColumnBuilder as J, TableAliasProxyHandler as K, PgColumnBuilder as L, PgColumn as M, pgTableWithSchema as N, pgViewWithSchema as O, PgDialect as P, QueryPromise as Q, Relation as R, SQL as S, Table as T, pgMaterializedViewWithSchema as U, View as V, WithSubquery as W, CheckBuilder as X, Check as Y, check as Z, PgArrayBuilder as _, Param as a, RelationTableAliasProxyHandler as a$, PgDateBuilder as a0, PgDate as a1, PgDateStringBuilder as a2, PgDateString as a3, date as a4, PgJsonBuilder as a5, PgJson as a6, json as a7, PgJsonbBuilder as a8, PgJsonb as a9, PrimaryKey as aA, PgSelectQueryBuilder as aB, PgSelect as aC, InlineForeignKeys as aD, PgTable as aE, pgTable as aF, pgTableCreator as aG, getTableConfig as aH, getViewConfig as aI, getMaterializedViewConfig as aJ, parsePgNestedArray as aK, parsePgArray as aL, makePgArray as aM, DefaultViewBuilderCore as aN, ViewBuilder as aO, ManualViewBuilder as aP, MaterializedViewBuilderCore as aQ, MaterializedViewBuilder as aR, ManualMaterializedViewBuilder as aS, PgViewBase as aT, PgViewConfig as aU, PgView as aV, PgMaterializedViewConfig as aW, PgMaterializedView as aX, pgView as aY, pgMaterializedView as aZ, ColumnAliasProxyHandler as a_, jsonb as aa, PgNumericBuilder as ab, PgNumeric as ac, numeric as ad, decimal as ae, PgTimeBuilder as af, PgTime as ag, time as ah, PgTimestampBuilder as ai, PgTimestamp as aj, PgTimestampStringBuilder as ak, PgTimestampString as al, timestamp as am, PgUUIDBuilder as an, PgUUID as ao, uuid as ap, ForeignKeyBuilder as aq, ForeignKey as ar, foreignKey as as, IndexBuilderOn as at, IndexBuilder as au, Index as av, index as aw, uniqueIndex as ax, primaryKey as ay, PrimaryKeyBuilder as az, mapUpdateSet as b, bindIfParam as b0, ne as b1, not as b2, gt as b3, gte as b4, lt as b5, lte as b6, inArray as b7, notInArray as b8, isNull as b9, placeholder as bA, TableName as bB, Schema as bC, Columns as bD, OriginalName as bE, BaseName as bF, IsAlias as bG, ExtraConfigBuilder as bH, isTable as bI, iife as bJ, isNotNull as ba, exists as bb, notExists as bc, between as bd, notBetween as be, like as bf, notLike as bg, ilike as bh, notIlike as bi, asc as bj, desc as bk, Relations as bl, One as bm, Many as bn, relations as bo, createOne as bp, createMany as bq, FakePrimitiveParam as br, isSQLWrapper as bs, StringChunk as bt, Name as bu, isDriverValueEncoder as bv, noopDecoder as bw, noopEncoder as bx, noopMapper as by, Placeholder as bz, createTableRelationsHelpers as c, mapRelationalRow as d, extractTablesRelationalConfig as e, fillPlaceholders as f, QueryBuilder as g, SelectionProxyHandler as h, PgSelectBuilder as i, getTableColumns as j, getTableName as k, Subquery as l, mapResultRow as m, name as n, orderSelectedFields as o, SubqueryConfig as p, ViewBaseConfig as q, param as r, sql as s, tracer as t, aliasedTableColumn as u, aliasedRelation as v, mapColumnsInAliasedSQLToAlias as w, operators as x, mapColumnsInSQLToAlias as y, orderByOperators as z };
+//# sourceMappingURL=relations-d3070559.mjs.map