drizzle-kit 0.30.3 → 0.30.4-4647df7

package/api.js

@@ -22090,13 +22090,14 @@ var init_subquery = __esm({
     init_entity();
     _a16 = entityKind;
     Subquery = class {
-      constructor(sql2, selection, alias, isWith = false) {
+      constructor(sql2, fields, alias, isWith = false, usedTables = []) {
         this._ = {
           brand: "Subquery",
           sql: sql2,
-          selectedFields: selection,
+          selectedFields: fields,
           alias,
-          isWith
+          isWith,
+          usedTables
         };
       }
       // getSQL(): SQL<unknown> {
@@ -22115,7 +22116,7 @@ var version;
 var init_version = __esm({
   "../drizzle-orm/dist/version.js"() {
     "use strict";
-    version = "0.39.0";
+    version = "0.39.2";
   }
 });
 
@@ -22338,7 +22339,14 @@ var init_sql = __esm({
         /** @internal */
         __publicField(this, "decoder", noopDecoder);
         __publicField(this, "shouldInlineParams", false);
+        /** @internal */
+        __publicField(this, "usedTables", []);
         this.queryChunks = queryChunks;
+        for (const chunk of queryChunks) {
+          if (is(chunk, Table2)) {
+            this.usedTables.push(chunk[Table2.Symbol.Schema] ?? "public." + chunk[Table2.Symbol.Name]);
+          }
+        }
       }
       append(query) {
         this.queryChunks.push(...query.queryChunks);
@@ -22398,7 +22406,7 @@ var init_sql = __esm({
             const schemaName = chunk[Table2.Symbol.Schema];
             const tableName = chunk[Table2.Symbol.Name];
             return {
-              sql: schemaName === void 0 ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+              sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
               params: []
             };
           }
@@ -22417,7 +22425,7 @@ var init_sql = __esm({
             const schemaName = chunk[ViewBaseConfig].schema;
             const viewName = chunk[ViewBaseConfig].name;
             return {
-              sql: schemaName === void 0 ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+              sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
               params: []
             };
           }
@@ -25669,107 +25677,164 @@ var init_selection_proxy = __esm({
   }
 });
 
-// ../drizzle-orm/dist/pg-core/query-builders/delete.js
-var _a125, _b97, PgDeleteBase;
-var init_delete = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/delete.js"() {
+// ../drizzle-orm/dist/pg-core/indexes.js
+var _a125, IndexBuilderOn, _a126, IndexBuilder, _a127, Index2;
+var init_indexes = __esm({
+  "../drizzle-orm/dist/pg-core/indexes.js"() {
     "use strict";
+    init_sql();
     init_entity();
-    init_query_promise();
-    init_selection_proxy();
-    init_table();
-    init_tracing();
-    init_utils2();
-    PgDeleteBase = class extends (_b97 = QueryPromise, _a125 = entityKind, _b97) {
-      constructor(table5, session, dialect6, withList) {
-        super();
-        __publicField(this, "config");
-        __publicField(this, "authToken");
-        __publicField(this, "execute", (placeholderValues) => {
-          return tracer.startActiveSpan("drizzle.operation", () => {
-            return this._prepare().execute(placeholderValues, this.authToken);
-          });
-        });
-        this.session = session;
-        this.dialect = dialect6;
-        this.config = { table: table5, withList };
+    init_columns();
+    _a125 = entityKind;
+    IndexBuilderOn = class {
+      constructor(unique, name2) {
+        this.unique = unique;
+        this.name = name2;
+      }
+      on(...columns) {
+        return new IndexBuilder(
+          columns.map((it) => {
+            if (is(it, SQL)) {
+              return it;
+            }
+            it = it;
+            const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+            it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+            return clonedIndexedColumn;
+          }),
+          this.unique,
+          false,
+          this.name
+        );
+      }
+      onOnly(...columns) {
+        return new IndexBuilder(
+          columns.map((it) => {
+            if (is(it, SQL)) {
+              return it;
+            }
+            it = it;
+            const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+            it.indexConfig = it.defaultConfig;
+            return clonedIndexedColumn;
+          }),
+          this.unique,
+          true,
+          this.name
+        );
       }
       /**
-       * Adds a `where` clause to the query.
-       *
-       * Calling this method will delete only those rows that fulfill a specified condition.
-       *
-       * See docs: {@link https://orm.drizzle.team/docs/delete}
-       *
-       * @param where the `where` clause.
-       *
-       * @example
-       * You can use conditional operators and `sql function` to filter the rows to be deleted.
-       *
-       * ```ts
-       * // Delete all cars with green color
-       * await db.delete(cars).where(eq(cars.color, 'green'));
-       * // or
-       * await db.delete(cars).where(sql`${cars.color} = 'green'`)
-       * ```
+       * Specify what index method to use. Choices are `btree`, `hash`, `gist`, `spgist`, `gin`, `brin`, or user-installed access methods like `bloom`. The default method is `btree.
        *
-       * You can logically combine conditional operators with `and()` and `or()` operators:
+       * If you have the `pg_vector` extension installed in your database, you can use the `hnsw` and `ivfflat` options, which are predefined types.
        *
-       * ```ts
-       * // Delete all BMW cars with a green color
-       * await db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+       * **You can always specify any string you want in the method, in case Drizzle doesn't have it natively in its types**
        *
-       * // Delete all cars with the green or blue color
-       * await db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
-       * ```
+       * @param method The name of the index method to be used
+       * @param columns
+       * @returns
        */
-      where(where) {
-        this.config.where = where;
-        return this;
+      using(method, ...columns) {
+        return new IndexBuilder(
+          columns.map((it) => {
+            if (is(it, SQL)) {
+              return it;
+            }
+            it = it;
+            const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+            it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+            return clonedIndexedColumn;
+          }),
+          this.unique,
+          true,
+          this.name,
+          method
+        );
       }
-      returning(fields = this.config.table[Table2.Symbol.Columns]) {
-        this.config.returningFields = fields;
-        this.config.returning = orderSelectedFields(fields);
+    };
+    __publicField(IndexBuilderOn, _a125, "PgIndexBuilderOn");
+    _a126 = entityKind;
+    IndexBuilder = class {
+      constructor(columns, unique, only, name2, method = "btree") {
+        /** @internal */
+        __publicField(this, "config");
+        this.config = {
+          name: name2,
+          columns,
+          unique,
+          only,
+          method
+        };
+      }
+      concurrently() {
+        this.config.concurrently = true;
         return this;
       }
-      /** @internal */
-      getSQL() {
-        return this.dialect.buildDeleteQuery(this.config);
+      with(obj) {
+        this.config.with = obj;
+        return this;
       }
-      toSQL() {
-        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-        return rest;
+      where(condition) {
+        this.config.where = condition;
+        return this;
       }
       /** @internal */
-      _prepare(name2) {
-        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
-          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
-        });
-      }
-      prepare(name2) {
-        return this._prepare(name2);
+      build(table5) {
+        return new Index2(this.config, table5);
       }
-      /** @internal */
-      setToken(token) {
-        this.authToken = token;
-        return this;
+    };
+    __publicField(IndexBuilder, _a126, "PgIndexBuilder");
+    _a127 = entityKind;
+    Index2 = class {
+      constructor(config, table5) {
+        __publicField(this, "config");
+        this.config = { ...config, table: table5 };
       }
-      /** @internal */
-      getSelectedFields() {
-        return this.config.returningFields ? new Proxy(
-          this.config.returningFields,
-          new SelectionProxyHandler({
-            alias: getTableName(this.config.table),
-            sqlAliasedBehavior: "alias",
-            sqlBehavior: "error"
-          })
-        ) : void 0;
+    };
+    __publicField(Index2, _a127, "PgIndex");
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/policies.js
+var _a128, PgPolicy;
+var init_policies = __esm({
+  "../drizzle-orm/dist/pg-core/policies.js"() {
+    "use strict";
+    init_entity();
+    _a128 = entityKind;
+    PgPolicy = class {
+      constructor(name2, config) {
+        __publicField(this, "as");
+        __publicField(this, "for");
+        __publicField(this, "to");
+        __publicField(this, "using");
+        __publicField(this, "withCheck");
+        /** @internal */
+        __publicField(this, "_linkedTable");
+        this.name = name2;
+        if (config) {
+          this.as = config.as;
+          this.for = config.for;
+          this.to = config.to;
+          this.using = config.using;
+          this.withCheck = config.withCheck;
+        }
       }
-      $dynamic() {
+      link(table5) {
+        this._linkedTable = table5;
         return this;
       }
     };
-    __publicField(PgDeleteBase, _a125, "PgDelete");
+    __publicField(PgPolicy, _a128, "PgPolicy");
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/view-common.js
+var PgViewConfig;
+var init_view_common2 = __esm({
+  "../drizzle-orm/dist/pg-core/view-common.js"() {
+    "use strict";
+    PgViewConfig = Symbol.for("drizzle:PgViewConfig");
   }
 });
 
@@ -25788,13 +25853,13 @@ function toCamelCase(input) {
 function noopCase(input) {
   return input;
 }
-var _a126, CasingCache;
+var _a129, CasingCache;
 var init_casing = __esm({
   "../drizzle-orm/dist/casing.js"() {
     "use strict";
     init_entity();
     init_table();
-    _a126 = entityKind;
+    _a129 = entityKind;
     CasingCache = class {
       constructor(casing2) {
         /** @internal */
@@ -25831,25 +25896,25 @@ var init_casing = __esm({
         this.cachedTables = {};
       }
     };
-    __publicField(CasingCache, _a126, "CasingCache");
+    __publicField(CasingCache, _a129, "CasingCache");
   }
 });
 
 // ../drizzle-orm/dist/pg-core/view-base.js
-var _a127, _b98, PgViewBase;
+var _a130, _b97, PgViewBase;
 var init_view_base = __esm({
   "../drizzle-orm/dist/pg-core/view-base.js"() {
     "use strict";
     init_entity();
     init_sql();
-    PgViewBase = class extends (_b98 = View3, _a127 = entityKind, _b98) {
+    PgViewBase = class extends (_b97 = View3, _a130 = entityKind, _b97) {
     };
-    __publicField(PgViewBase, _a127, "PgViewBase");
+    __publicField(PgViewBase, _a130, "PgViewBase");
   }
 });
 
 // ../drizzle-orm/dist/pg-core/dialect.js
-var _a128, PgDialect;
+var _a131, PgDialect;
 var init_dialect = __esm({
   "../drizzle-orm/dist/pg-core/dialect.js"() {
     "use strict";
@@ -25868,7 +25933,7 @@ var init_dialect = __esm({
     init_utils2();
     init_view_common();
     init_view_base();
-    _a128 = entityKind;
+    _a131 = entityKind;
     PgDialect = class {
       constructor(config) {
         /** @internal */
@@ -26960,24 +27025,24 @@ var init_dialect = __esm({
         };
       }
     };
-    __publicField(PgDialect, _a128, "PgDialect");
+    __publicField(PgDialect, _a131, "PgDialect");
   }
 });
 
 // ../drizzle-orm/dist/query-builders/query-builder.js
-var _a129, TypedQueryBuilder;
+var _a132, TypedQueryBuilder;
 var init_query_builder = __esm({
   "../drizzle-orm/dist/query-builders/query-builder.js"() {
     "use strict";
     init_entity();
-    _a129 = entityKind;
+    _a132 = entityKind;
     TypedQueryBuilder = class {
       /** @internal */
       getSelectedFields() {
         return this._.selectedFields;
       }
     };
-    __publicField(TypedQueryBuilder, _a129, "TypedQueryBuilder");
+    __publicField(TypedQueryBuilder, _a132, "TypedQueryBuilder");
   }
 });
 
@@ -26999,7 +27064,7 @@ function createSetOperator(type, isAll) {
     return leftSelect.addSetOperators(setOperators);
   };
 }
-var _a130, PgSelectBuilder, _a131, _b99, PgSelectQueryBuilderBase, _a132, _b100, PgSelectBase, getPgSetOperators, union, unionAll, intersect, intersectAll, except, exceptAll;
+var _a133, PgSelectBuilder, _a134, _b98, PgSelectQueryBuilderBase, _a135, _b99, PgSelectBase, getPgSetOperators, union, unionAll, intersect, intersectAll, except, exceptAll;
 var init_select2 = __esm({
   "../drizzle-orm/dist/pg-core/query-builders/select.js"() {
     "use strict";
@@ -27015,7 +27080,8 @@ var init_select2 = __esm({
     init_utils2();
     init_utils2();
     init_view_common();
-    _a130 = entityKind;
+    init_utils4();
+    _a133 = entityKind;
     PgSelectBuilder = class {
       constructor(config) {
         __publicField(this, "fields");
@@ -27071,8 +27137,8 @@ var init_select2 = __esm({
         }).setToken(this.authToken);
       }
     };
-    __publicField(PgSelectBuilder, _a130, "PgSelectBuilder");
-    PgSelectQueryBuilderBase = class extends (_b99 = TypedQueryBuilder, _a131 = entityKind, _b99) {
+    __publicField(PgSelectBuilder, _a133, "PgSelectBuilder");
+    PgSelectQueryBuilderBase = class extends (_b98 = TypedQueryBuilder, _a134 = entityKind, _b98) {
       constructor({ table: table5, fields, isPartialSelect, session, dialect: dialect6, withList, distinct }) {
         super();
         __publicField(this, "_");
@@ -27082,6 +27148,8 @@ var init_select2 = __esm({
         __publicField(this, "isPartialSelect");
         __publicField(this, "session");
         __publicField(this, "dialect");
+        __publicField(this, "cacheConfig");
+        __publicField(this, "usedTables", /* @__PURE__ */ new Set());
         /**
          * Executes a `left join` operation by adding another table to the current query.
          *
@@ -27391,15 +27459,24 @@ var init_select2 = __esm({
         this.session = session;
         this.dialect = dialect6;
         this._ = {
-          selectedFields: fields
+          selectedFields: fields,
+          config: this.config
         };
         this.tableName = getTableLikeName(table5);
         this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
+        for (const item of extractUsedTable(table5))
+          this.usedTables.add(item);
+      }
+      /** @internal */
+      getUsedTables() {
+        return [...this.usedTables];
       }
       createJoin(joinType) {
         return (table5, on) => {
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table5);
+          for (const item of extractUsedTable(table5))
+            this.usedTables.add(item);
           if (typeof tableName === "string" && this.config.joins?.some((join) => join.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
@@ -27656,8 +27733,14 @@ var init_select2 = __esm({
         return rest;
       }
       as(alias) {
+        const usedTables = [];
+        usedTables.push(...extractUsedTable(this.config.table));
+        if (this.config.joins) {
+          for (const it of this.config.joins)
+            usedTables.push(...extractUsedTable(it.table));
+        }
         return new Proxy(
-          new Subquery(this.getSQL(), this.config.fields, alias),
+          new Subquery(this.getSQL(), this.config.fields, alias, false, [...new Set(usedTables)]),
           new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
         );
       }
@@ -27671,9 +27754,13 @@ var init_select2 = __esm({
       $dynamic() {
         return this;
       }
+      $withCache(config) {
+        this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
+        return this;
+      }
     };
-    __publicField(PgSelectQueryBuilderBase, _a131, "PgSelectQueryBuilder");
-    PgSelectBase = class extends (_b100 = PgSelectQueryBuilderBase, _a132 = entityKind, _b100) {
+    __publicField(PgSelectQueryBuilderBase, _a134, "PgSelectQueryBuilder");
+    PgSelectBase = class extends (_b99 = PgSelectQueryBuilderBase, _a135 = entityKind, _b99) {
       constructor() {
         super(...arguments);
         __publicField(this, "authToken");
@@ -27685,13 +27772,17 @@ var init_select2 = __esm({
       }
       /** @internal */
       _prepare(name2) {
-        const { session, config, dialect: dialect6, joinsNotNullableMap, authToken } = this;
+        const { session, config, dialect: dialect6, joinsNotNullableMap, authToken, cacheConfig, usedTables } = this;
         if (!session) {
           throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
         }
+        const { fields } = config;
         return tracer.startActiveSpan("drizzle.prepareQuery", () => {
-          const fieldsList = orderSelectedFields(config.fields);
-          const query = session.prepareQuery(dialect6.sqlToQuery(this.getSQL()), fieldsList, name2, true);
+          const fieldsList = orderSelectedFields(fields);
+          const query = session.prepareQuery(dialect6.sqlToQuery(this.getSQL()), fieldsList, name2, true, void 0, {
+            type: "select",
+            tables: [...usedTables]
+          }, cacheConfig);
           query.joinsNotNullableMap = joinsNotNullableMap;
           return query.setToken(authToken);
         });
@@ -27712,7 +27803,7 @@ var init_select2 = __esm({
         return this;
       }
     };
-    __publicField(PgSelectBase, _a132, "PgSelect");
+    __publicField(PgSelectBase, _a135, "PgSelect");
     applyMixins(PgSelectBase, [QueryPromise]);
     getPgSetOperators = () => ({
       union,
@@ -27732,7 +27823,7 @@ var init_select2 = __esm({
 });
 
 // ../drizzle-orm/dist/pg-core/query-builders/query-builder.js
-var _a133, QueryBuilder;
+var _a136, QueryBuilder;
 var init_query_builder2 = __esm({
   "../drizzle-orm/dist/pg-core/query-builders/query-builder.js"() {
     "use strict";
@@ -27741,7 +27832,7 @@ var init_query_builder2 = __esm({
     init_selection_proxy();
     init_subquery();
     init_select2();
-    _a133 = entityKind;
+    _a136 = entityKind;
     QueryBuilder = class {
       constructor(dialect6) {
         __publicField(this, "dialect");
@@ -27826,226 +27917,374 @@ var init_query_builder2 = __esm({
         return this.dialect;
       }
     };
-    __publicField(QueryBuilder, _a133, "PgQueryBuilder");
+    __publicField(QueryBuilder, _a136, "PgQueryBuilder");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/query-builders/insert.js
-var _a134, PgInsertBuilder, _a135, _b101, PgInsertBase;
-var init_insert = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
+// ../drizzle-orm/dist/pg-core/view.js
+function pgViewWithSchema(name2, selection, schema5) {
+  if (selection) {
+    return new ManualViewBuilder(name2, selection, schema5);
+  }
+  return new ViewBuilder(name2, schema5);
+}
+function pgMaterializedViewWithSchema(name2, selection, schema5) {
+  if (selection) {
+    return new ManualMaterializedViewBuilder(name2, selection, schema5);
+  }
+  return new MaterializedViewBuilder(name2, schema5);
+}
+function isPgView(obj) {
+  return is(obj, PgView2);
+}
+function isPgMaterializedView(obj) {
+  return is(obj, PgMaterializedView);
+}
+var _a137, DefaultViewBuilderCore, _a138, _b100, ViewBuilder, _a139, _b101, ManualViewBuilder, _a140, MaterializedViewBuilderCore, _a141, _b102, MaterializedViewBuilder, _a142, _b103, ManualMaterializedViewBuilder, _a143, _b104, _c4, PgView2, PgMaterializedViewConfig, _a144, _b105, _c5, PgMaterializedView;
+var init_view = __esm({
+  "../drizzle-orm/dist/pg-core/view.js"() {
     "use strict";
     init_entity();
-    init_query_promise();
     init_selection_proxy();
-    init_sql();
-    init_table();
-    init_tracing();
     init_utils2();
     init_query_builder2();
-    _a134 = entityKind;
-    PgInsertBuilder = class {
-      constructor(table5, session, dialect6, withList, overridingSystemValue_) {
-        __publicField(this, "authToken");
-        this.table = table5;
-        this.session = session;
-        this.dialect = dialect6;
-        this.withList = withList;
-        this.overridingSystemValue_ = overridingSystemValue_;
-      }
-      /** @internal */
-      setToken(token) {
-        this.authToken = token;
-        return this;
+    init_table2();
+    init_view_base();
+    init_view_common2();
+    _a137 = entityKind;
+    DefaultViewBuilderCore = class {
+      constructor(name2, schema5) {
+        __publicField(this, "config", {});
+        this.name = name2;
+        this.schema = schema5;
       }
-      overridingSystemValue() {
-        this.overridingSystemValue_ = true;
+      with(config) {
+        this.config.with = config;
         return this;
       }
-      values(values) {
-        values = Array.isArray(values) ? values : [values];
-        if (values.length === 0) {
-          throw new Error("values() must be called with at least one value");
+    };
+    __publicField(DefaultViewBuilderCore, _a137, "PgDefaultViewBuilderCore");
+    ViewBuilder = class extends (_b100 = DefaultViewBuilderCore, _a138 = entityKind, _b100) {
+      as(qb) {
+        if (typeof qb === "function") {
+          qb = qb(new QueryBuilder());
         }
-        const mappedValues = values.map((entry) => {
-          const result = {};
-          const cols = this.table[Table2.Symbol.Columns];
-          for (const colKey of Object.keys(entry)) {
-            const colValue = entry[colKey];
-            result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
-          }
-          return result;
+        const selectionProxy = new SelectionProxyHandler({
+          alias: this.name,
+          sqlBehavior: "error",
+          sqlAliasedBehavior: "alias",
+          replaceOriginalName: true
         });
-        return new PgInsertBase(
-          this.table,
-          mappedValues,
-          this.session,
-          this.dialect,
-          this.withList,
-          false,
-          this.overridingSystemValue_
-        ).setToken(this.authToken);
-      }
-      select(selectQuery) {
-        const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
-        if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
-          throw new Error(
-            "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
-          );
-        }
-        return new PgInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+        return new Proxy(
+          new PgView2({
+            pgConfig: this.config,
+            config: {
+              name: this.name,
+              schema: this.schema,
+              selectedFields: aliasedSelection,
+              query: qb.getSQL().inlineParams()
+            }
+          }),
+          selectionProxy
+        );
       }
     };
-    __publicField(PgInsertBuilder, _a134, "PgInsertBuilder");
-    PgInsertBase = class extends (_b101 = QueryPromise, _a135 = entityKind, _b101) {
-      constructor(table5, values, session, dialect6, withList, select, overridingSystemValue_) {
-        super();
-        __publicField(this, "config");
-        __publicField(this, "authToken");
-        __publicField(this, "execute", (placeholderValues) => {
-          return tracer.startActiveSpan("drizzle.operation", () => {
-            return this._prepare().execute(placeholderValues, this.authToken);
-          });
-        });
-        this.session = session;
-        this.dialect = dialect6;
-        this.config = { table: table5, values, withList, select, overridingSystemValue_ };
-      }
-      returning(fields = this.config.table[Table2.Symbol.Columns]) {
-        this.config.returningFields = fields;
-        this.config.returning = orderSelectedFields(fields);
-        return this;
-      }
-      /**
-       * Adds an `on conflict do nothing` clause to the query.
-       *
-       * Calling this method simply avoids inserting a row as its alternative action.
-       *
-       * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
-       *
-       * @param config The `target` and `where` clauses.
-       *
-       * @example
-       * ```ts
-       * // Insert one row and cancel the insert if there's a conflict
-       * await db.insert(cars)
-       *   .values({ id: 1, brand: 'BMW' })
-       *   .onConflictDoNothing();
-       *
-       * // Explicitly specify conflict target
-       * await db.insert(cars)
-       *   .values({ id: 1, brand: 'BMW' })
-       *   .onConflictDoNothing({ target: cars.id });
-       * ```
-       */
-      onConflictDoNothing(config = {}) {
-        if (config.target === void 0) {
-          this.config.onConflict = sql`do nothing`;
-        } else {
-          let targetColumn = "";
-          targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
-          const whereSql = config.where ? sql` where ${config.where}` : void 0;
-          this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
-        }
-        return this;
-      }
-      /**
-       * Adds an `on conflict do update` clause to the query.
-       *
-       * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
-       *
-       * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
-       *
-       * @param config The `target`, `set` and `where` clauses.
-       *
-       * @example
-       * ```ts
-       * // Update the row if there's a conflict
-       * await db.insert(cars)
-       *   .values({ id: 1, brand: 'BMW' })
-       *   .onConflictDoUpdate({
-       *     target: cars.id,
-       *     set: { brand: 'Porsche' }
-       *   });
-       *
-       * // Upsert with 'where' clause
-       * await db.insert(cars)
-       *   .values({ id: 1, brand: 'BMW' })
-       *   .onConflictDoUpdate({
-       *     target: cars.id,
-       *     set: { brand: 'newBMW' },
-       *     targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
-       *   });
-       * ```
-       */
-      onConflictDoUpdate(config) {
-        if (config.where && (config.targetWhere || config.setWhere)) {
-          throw new Error(
-            'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
-          );
-        }
-        const whereSql = config.where ? sql` where ${config.where}` : void 0;
-        const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
-        const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
-        const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
-        let targetColumn = "";
-        targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
-        this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
-        return this;
+    __publicField(ViewBuilder, _a138, "PgViewBuilder");
+    ManualViewBuilder = class extends (_b101 = DefaultViewBuilderCore, _a139 = entityKind, _b101) {
+      constructor(name2, columns, schema5) {
+        super(name2, schema5);
+        __publicField(this, "columns");
+        this.columns = getTableColumns(pgTable(name2, columns));
       }
-      /** @internal */
-      getSQL() {
-        return this.dialect.buildInsertQuery(this.config);
+      existing() {
+        return new Proxy(
+          new PgView2({
+            pgConfig: void 0,
+            config: {
+              name: this.name,
+              schema: this.schema,
+              selectedFields: this.columns,
+              query: void 0
+            }
+          }),
+          new SelectionProxyHandler({
+            alias: this.name,
+            sqlBehavior: "error",
+            sqlAliasedBehavior: "alias",
+            replaceOriginalName: true
+          })
+        );
       }
-      toSQL() {
-        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
-        return rest;
+      as(query) {
+        return new Proxy(
+          new PgView2({
+            pgConfig: this.config,
+            config: {
+              name: this.name,
+              schema: this.schema,
+              selectedFields: this.columns,
+              query: query.inlineParams()
+            }
+          }),
+          new SelectionProxyHandler({
+            alias: this.name,
+            sqlBehavior: "error",
+            sqlAliasedBehavior: "alias",
+            replaceOriginalName: true
+          })
+        );
       }
-      /** @internal */
-      _prepare(name2) {
-        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
-          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
-        });
+    };
+    __publicField(ManualViewBuilder, _a139, "PgManualViewBuilder");
+    _a140 = entityKind;
+    MaterializedViewBuilderCore = class {
+      constructor(name2, schema5) {
+        __publicField(this, "config", {});
+        this.name = name2;
+        this.schema = schema5;
       }
-      prepare(name2) {
-        return this._prepare(name2);
+      using(using) {
+        this.config.using = using;
+        return this;
       }
-      /** @internal */
-      setToken(token) {
-        this.authToken = token;
+      with(config) {
+        this.config.with = config;
         return this;
       }
-      /** @internal */
-      getSelectedFields() {
-        return this.config.returningFields ? new Proxy(
-          this.config.returningFields,
-          new SelectionProxyHandler({
-            alias: getTableName(this.config.table),
-            sqlAliasedBehavior: "alias",
-            sqlBehavior: "error"
-          })
-        ) : void 0;
+      tablespace(tablespace) {
+        this.config.tablespace = tablespace;
+        return this;
       }
-      $dynamic() {
+      withNoData() {
+        this.config.withNoData = true;
         return this;
       }
     };
-    __publicField(PgInsertBase, _a135, "PgInsert");
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js
-var _a136, _b102, PgRefreshMaterializedView;
-var init_refresh_materialized_view = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js"() {
+    __publicField(MaterializedViewBuilderCore, _a140, "PgMaterializedViewBuilderCore");
+    MaterializedViewBuilder = class extends (_b102 = MaterializedViewBuilderCore, _a141 = entityKind, _b102) {
+      as(qb) {
+        if (typeof qb === "function") {
+          qb = qb(new QueryBuilder());
+        }
+        const selectionProxy = new SelectionProxyHandler({
+          alias: this.name,
+          sqlBehavior: "error",
+          sqlAliasedBehavior: "alias",
+          replaceOriginalName: true
+        });
+        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
+        return new Proxy(
+          new PgMaterializedView({
+            pgConfig: {
+              with: this.config.with,
+              using: this.config.using,
+              tablespace: this.config.tablespace,
+              withNoData: this.config.withNoData
+            },
+            config: {
+              name: this.name,
+              schema: this.schema,
+              selectedFields: aliasedSelection,
+              query: qb.getSQL().inlineParams()
+            }
+          }),
+          selectionProxy
+        );
+      }
+    };
+    __publicField(MaterializedViewBuilder, _a141, "PgMaterializedViewBuilder");
+    ManualMaterializedViewBuilder = class extends (_b103 = MaterializedViewBuilderCore, _a142 = entityKind, _b103) {
+      constructor(name2, columns, schema5) {
+        super(name2, schema5);
+        __publicField(this, "columns");
+        this.columns = getTableColumns(pgTable(name2, columns));
+      }
+      existing() {
+        return new Proxy(
+          new PgMaterializedView({
+            pgConfig: {
+              tablespace: this.config.tablespace,
+              using: this.config.using,
+              with: this.config.with,
+              withNoData: this.config.withNoData
+            },
+            config: {
+              name: this.name,
+              schema: this.schema,
+              selectedFields: this.columns,
+              query: void 0
+            }
+          }),
+          new SelectionProxyHandler({
+            alias: this.name,
+            sqlBehavior: "error",
+            sqlAliasedBehavior: "alias",
+            replaceOriginalName: true
+          })
+        );
+      }
+      as(query) {
+        return new Proxy(
+          new PgMaterializedView({
+            pgConfig: {
+              tablespace: this.config.tablespace,
+              using: this.config.using,
+              with: this.config.with,
+              withNoData: this.config.withNoData
+            },
+            config: {
+              name: this.name,
+              schema: this.schema,
+              selectedFields: this.columns,
+              query: query.inlineParams()
+            }
+          }),
+          new SelectionProxyHandler({
+            alias: this.name,
+            sqlBehavior: "error",
+            sqlAliasedBehavior: "alias",
+            replaceOriginalName: true
+          })
+        );
+      }
+    };
+    __publicField(ManualMaterializedViewBuilder, _a142, "PgManualMaterializedViewBuilder");
+    PgView2 = class extends (_c4 = PgViewBase, _b104 = entityKind, _a143 = PgViewConfig, _c4) {
+      constructor({ pgConfig, config }) {
+        super(config);
+        __publicField(this, _a143);
+        if (pgConfig) {
+          this[PgViewConfig] = {
+            with: pgConfig.with
+          };
+        }
+      }
+    };
+    __publicField(PgView2, _b104, "PgView");
+    PgMaterializedViewConfig = Symbol.for("drizzle:PgMaterializedViewConfig");
+    PgMaterializedView = class extends (_c5 = PgViewBase, _b105 = entityKind, _a144 = PgMaterializedViewConfig, _c5) {
+      constructor({ pgConfig, config }) {
+        super(config);
+        __publicField(this, _a144);
+        this[PgMaterializedViewConfig] = {
+          with: pgConfig?.with,
+          using: pgConfig?.using,
+          tablespace: pgConfig?.tablespace,
+          withNoData: pgConfig?.withNoData
+        };
+      }
+    };
+    __publicField(PgMaterializedView, _b105, "PgMaterializedView");
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/utils.js
+function getTableConfig(table5) {
+  const columns = Object.values(table5[Table2.Symbol.Columns]);
+  const indexes = [];
+  const checks = [];
+  const primaryKeys = [];
+  const foreignKeys = Object.values(table5[PgTable.Symbol.InlineForeignKeys]);
+  const uniqueConstraints = [];
+  const name2 = table5[Table2.Symbol.Name];
+  const schema5 = table5[Table2.Symbol.Schema];
+  const policies = [];
+  const enableRLS = table5[PgTable.Symbol.EnableRLS];
+  const extraConfigBuilder = table5[PgTable.Symbol.ExtraConfigBuilder];
+  if (extraConfigBuilder !== void 0) {
+    const extraConfig = extraConfigBuilder(table5[Table2.Symbol.ExtraConfigColumns]);
+    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
+    for (const builder of extraValues) {
+      if (is(builder, IndexBuilder)) {
+        indexes.push(builder.build(table5));
+      } else if (is(builder, CheckBuilder)) {
+        checks.push(builder.build(table5));
+      } else if (is(builder, UniqueConstraintBuilder)) {
+        uniqueConstraints.push(builder.build(table5));
+      } else if (is(builder, PrimaryKeyBuilder)) {
+        primaryKeys.push(builder.build(table5));
+      } else if (is(builder, ForeignKeyBuilder)) {
+        foreignKeys.push(builder.build(table5));
+      } else if (is(builder, PgPolicy)) {
+        policies.push(builder);
+      }
+    }
+  }
+  return {
+    columns,
+    indexes,
+    foreignKeys,
+    checks,
+    primaryKeys,
+    uniqueConstraints,
+    name: name2,
+    schema: schema5,
+    policies,
+    enableRLS
+  };
+}
+function extractUsedTable(table5) {
+  if (is(table5, PgTable)) {
+    return [`${table5[Schema] ?? "public"}.${table5[Table2.Symbol.BaseName]}`];
+  }
+  if (is(table5, Subquery)) {
+    return table5._.usedTables ?? [];
+  }
+  if (is(table5, SQL)) {
+    return table5.usedTables ?? [];
+  }
+  return [];
+}
+function getViewConfig(view4) {
+  return {
+    ...view4[ViewBaseConfig],
+    ...view4[PgViewConfig]
+  };
+}
+function getMaterializedViewConfig(view4) {
+  return {
+    ...view4[ViewBaseConfig],
+    ...view4[PgMaterializedViewConfig]
+  };
+}
+var init_utils4 = __esm({
+  "../drizzle-orm/dist/pg-core/utils.js"() {
+    "use strict";
+    init_entity();
+    init_table2();
+    init_sql();
+    init_subquery();
+    init_table();
+    init_view_common();
+    init_checks();
+    init_foreign_keys();
+    init_indexes();
+    init_policies();
+    init_primary_keys();
+    init_unique_constraint();
+    init_view_common2();
+    init_view();
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/query-builders/delete.js
+var _a145, _b106, PgDeleteBase;
+var init_delete = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/delete.js"() {
     "use strict";
     init_entity();
     init_query_promise();
+    init_selection_proxy();
+    init_table();
     init_tracing();
-    PgRefreshMaterializedView = class extends (_b102 = QueryPromise, _a136 = entityKind, _b102) {
-      constructor(view4, session, dialect6) {
+    init_utils2();
+    init_utils4();
+    PgDeleteBase = class extends (_b106 = QueryPromise, _a145 = entityKind, _b106) {
+      constructor(table5, session, dialect6, withList) {
         super();
         __publicField(this, "config");
+        __publicField(this, "cacheConfig");
         __publicField(this, "authToken");
         __publicField(this, "execute", (placeholderValues) => {
           return tracer.startActiveSpan("drizzle.operation", () => {
@@ -28054,25 +28293,49 @@ var init_refresh_materialized_view = __esm({
         });
         this.session = session;
         this.dialect = dialect6;
-        this.config = { view: view4 };
+        this.config = { table: table5, withList };
       }
-      concurrently() {
-        if (this.config.withNoData !== void 0) {
-          throw new Error("Cannot use concurrently and withNoData together");
-        }
-        this.config.concurrently = true;
+      /**
+       * Adds a `where` clause to the query.
+       *
+       * Calling this method will delete only those rows that fulfill a specified condition.
+       *
+       * See docs: {@link https://orm.drizzle.team/docs/delete}
+       *
+       * @param where the `where` clause.
+       *
+       * @example
+       * You can use conditional operators and `sql function` to filter the rows to be deleted.
+       *
+       * ```ts
+       * // Delete all cars with green color
+       * await db.delete(cars).where(eq(cars.color, 'green'));
+       * // or
+       * await db.delete(cars).where(sql`${cars.color} = 'green'`)
+       * ```
+       *
+       * You can logically combine conditional operators with `and()` and `or()` operators:
+       *
+       * ```ts
+       * // Delete all BMW cars with a green color
+       * await db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+       *
+       * // Delete all cars with the green or blue color
+       * await db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+       * ```
+       */
+      where(where) {
+        this.config.where = where;
         return this;
       }
-      withNoData() {
-        if (this.config.concurrently !== void 0) {
-          throw new Error("Cannot use concurrently and withNoData together");
-        }
-        this.config.withNoData = true;
+      returning(fields = this.config.table[Table2.Symbol.Columns]) {
+        this.config.returningFields = fields;
+        this.config.returning = orderSelectedFields(fields);
         return this;
       }
       /** @internal */
       getSQL() {
-        return this.dialect.buildRefreshMaterializedViewQuery(this.config);
+        return this.dialect.buildDeleteQuery(this.config);
       }
       toSQL() {
         const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
@@ -28081,7 +28344,10 @@ var init_refresh_materialized_view = __esm({
       /** @internal */
       _prepare(name2) {
         return tracer.startActiveSpan("drizzle.prepareQuery", () => {
-          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, name2, true);
+          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true, void 0, {
+            type: "delete",
+            tables: extractUsedTable(this.config.table)
+          }, this.cacheConfig);
         });
       }
       prepare(name2) {
@@ -28092,204 +28358,193 @@ var init_refresh_materialized_view = __esm({
         this.authToken = token;
         return this;
       }
-    };
-    __publicField(PgRefreshMaterializedView, _a136, "PgRefreshMaterializedView");
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/query-builders/select.types.js
-var init_select_types = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/select.types.js"() {
-    "use strict";
+      /** @internal */
+      getSelectedFields() {
+        return this.config.returningFields ? new Proxy(
+          this.config.returningFields,
+          new SelectionProxyHandler({
+            alias: getTableName(this.config.table),
+            sqlAliasedBehavior: "alias",
+            sqlBehavior: "error"
+          })
+        ) : void 0;
+      }
+      $dynamic() {
+        return this;
+      }
+    };
+    __publicField(PgDeleteBase, _a145, "PgDelete");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/query-builders/update.js
-var _a137, PgUpdateBuilder, _a138, _b103, PgUpdateBase;
-var init_update = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/update.js"() {
+// ../drizzle-orm/dist/pg-core/query-builders/insert.js
+var _a146, PgInsertBuilder, _a147, _b107, PgInsertBase;
+var init_insert = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
     "use strict";
     init_entity();
-    init_table2();
     init_query_promise();
     init_selection_proxy();
     init_sql();
-    init_subquery();
     init_table();
+    init_tracing();
     init_utils2();
-    init_view_common();
-    _a137 = entityKind;
-    PgUpdateBuilder = class {
-      constructor(table5, session, dialect6, withList) {
+    init_utils4();
+    init_query_builder2();
+    _a146 = entityKind;
+    PgInsertBuilder = class {
+      constructor(table5, session, dialect6, withList, overridingSystemValue_) {
         __publicField(this, "authToken");
         this.table = table5;
         this.session = session;
         this.dialect = dialect6;
         this.withList = withList;
+        this.overridingSystemValue_ = overridingSystemValue_;
       }
+      /** @internal */
       setToken(token) {
         this.authToken = token;
         return this;
       }
-      set(values) {
-        return new PgUpdateBase(
+      overridingSystemValue() {
+        this.overridingSystemValue_ = true;
+        return this;
+      }
+      values(values) {
+        values = Array.isArray(values) ? values : [values];
+        if (values.length === 0) {
+          throw new Error("values() must be called with at least one value");
+        }
+        const mappedValues = values.map((entry) => {
+          const result = {};
+          const cols = this.table[Table2.Symbol.Columns];
+          for (const colKey of Object.keys(entry)) {
+            const colValue = entry[colKey];
+            result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
+          }
+          return result;
+        });
+        return new PgInsertBase(
           this.table,
-          mapUpdateSet(this.table, values),
+          mappedValues,
           this.session,
           this.dialect,
-          this.withList
+          this.withList,
+          false,
+          this.overridingSystemValue_
         ).setToken(this.authToken);
       }
+      select(selectQuery) {
+        const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
+        if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
+          throw new Error(
+            "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
+          );
+        }
+        return new PgInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
+      }
     };
-    __publicField(PgUpdateBuilder, _a137, "PgUpdateBuilder");
-    PgUpdateBase = class extends (_b103 = QueryPromise, _a138 = entityKind, _b103) {
-      constructor(table5, set, session, dialect6, withList) {
+    __publicField(PgInsertBuilder, _a146, "PgInsertBuilder");
+    PgInsertBase = class extends (_b107 = QueryPromise, _a147 = entityKind, _b107) {
+      constructor(table5, values, session, dialect6, withList, select, overridingSystemValue_) {
         super();
         __publicField(this, "config");
-        __publicField(this, "tableName");
-        __publicField(this, "joinsNotNullableMap");
-        __publicField(this, "leftJoin", this.createJoin("left"));
-        __publicField(this, "rightJoin", this.createJoin("right"));
-        __publicField(this, "innerJoin", this.createJoin("inner"));
-        __publicField(this, "fullJoin", this.createJoin("full"));
+        __publicField(this, "cacheConfig");
         __publicField(this, "authToken");
         __publicField(this, "execute", (placeholderValues) => {
-          return this._prepare().execute(placeholderValues, this.authToken);
+          return tracer.startActiveSpan("drizzle.operation", () => {
+            return this._prepare().execute(placeholderValues, this.authToken);
+          });
         });
         this.session = session;
         this.dialect = dialect6;
-        this.config = { set, table: table5, withList, joins: [] };
-        this.tableName = getTableLikeName(table5);
-        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
+        this.config = { table: table5, values, withList, select, overridingSystemValue_ };
       }
-      from(source) {
-        const src = source;
-        const tableName = getTableLikeName(src);
-        if (typeof tableName === "string") {
-          this.joinsNotNullableMap[tableName] = true;
-        }
-        this.config.from = src;
+      returning(fields = this.config.table[Table2.Symbol.Columns]) {
+        this.config.returningFields = fields;
+        this.config.returning = orderSelectedFields(fields);
         return this;
       }
-      getTableLikeFields(table5) {
-        if (is(table5, PgTable)) {
-          return table5[Table2.Symbol.Columns];
-        } else if (is(table5, Subquery)) {
-          return table5._.selectedFields;
-        }
-        return table5[ViewBaseConfig].selectedFields;
-      }
-      createJoin(joinType) {
-        return (table5, on) => {
-          const tableName = getTableLikeName(table5);
-          if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
-            throw new Error(`Alias "${tableName}" is already used in this query`);
-          }
-          if (typeof on === "function") {
-            const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;
-            on = on(
-              new Proxy(
-                this.config.table[Table2.Symbol.Columns],
-                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
-              ),
-              from && new Proxy(
-                from,
-                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
-              )
-            );
-          }
-          this.config.joins.push({ on, table: table5, joinType, alias: tableName });
-          if (typeof tableName === "string") {
-            switch (joinType) {
-              case "left": {
-                this.joinsNotNullableMap[tableName] = false;
-                break;
-              }
-              case "right": {
-                this.joinsNotNullableMap = Object.fromEntries(
-                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
-                );
-                this.joinsNotNullableMap[tableName] = true;
-                break;
-              }
-              case "inner": {
-                this.joinsNotNullableMap[tableName] = true;
-                break;
-              }
-              case "full": {
-                this.joinsNotNullableMap = Object.fromEntries(
-                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
-                );
-                this.joinsNotNullableMap[tableName] = false;
-                break;
-              }
-            }
-          }
-          return this;
-        };
-      }
       /**
-       * Adds a 'where' clause to the query.
+       * Adds an `on conflict do nothing` clause to the query.
        *
-       * Calling this method will update only those rows that fulfill a specified condition.
+       * Calling this method simply avoids inserting a row as its alternative action.
        *
-       * See docs: {@link https://orm.drizzle.team/docs/update}
+       * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
        *
-       * @param where the 'where' clause.
+       * @param config The `target` and `where` clauses.
        *
        * @example
-       * You can use conditional operators and `sql function` to filter the rows to be updated.
-       *
        * ```ts
-       * // Update all cars with green color
-       * await db.update(cars).set({ color: 'red' })
-       *   .where(eq(cars.color, 'green'));
-       * // or
-       * await db.update(cars).set({ color: 'red' })
-       *   .where(sql`${cars.color} = 'green'`)
+       * // Insert one row and cancel the insert if there's a conflict
+       * await db.insert(cars)
+       *   .values({ id: 1, brand: 'BMW' })
+       *   .onConflictDoNothing();
+       *
+       * // Explicitly specify conflict target
+       * await db.insert(cars)
+       *   .values({ id: 1, brand: 'BMW' })
+       *   .onConflictDoNothing({ target: cars.id });
        * ```
+       */
+      onConflictDoNothing(config = {}) {
+        if (config.target === void 0) {
+          this.config.onConflict = sql`do nothing`;
+        } else {
+          let targetColumn = "";
+          targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
+          const whereSql = config.where ? sql` where ${config.where}` : void 0;
+          this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
+        }
+        return this;
+      }
+      /**
+       * Adds an `on conflict do update` clause to the query.
        *
-       * You can logically combine conditional operators with `and()` and `or()` operators:
+       * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
+       *
+       * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
+       *
+       * @param config The `target`, `set` and `where` clauses.
        *
+       * @example
        * ```ts
-       * // Update all BMW cars with a green color
-       * await db.update(cars).set({ color: 'red' })
-       *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+       * // Update the row if there's a conflict
+       * await db.insert(cars)
+       *   .values({ id: 1, brand: 'BMW' })
+       *   .onConflictDoUpdate({
+       *     target: cars.id,
+       *     set: { brand: 'Porsche' }
+       *   });
        *
-       * // Update all cars with the green or blue color
-       * await db.update(cars).set({ color: 'red' })
-       *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
+       * // Upsert with 'where' clause
+       * await db.insert(cars)
+       *   .values({ id: 1, brand: 'BMW' })
+       *   .onConflictDoUpdate({
+       *     target: cars.id,
+       *     set: { brand: 'newBMW' },
+       *     targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
+       *   });
        * ```
        */
-      where(where) {
-        this.config.where = where;
-        return this;
-      }
-      returning(fields) {
-        if (!fields) {
-          fields = Object.assign({}, this.config.table[Table2.Symbol.Columns]);
-          if (this.config.from) {
-            const tableName = getTableLikeName(this.config.from);
-            if (typeof tableName === "string" && this.config.from && !is(this.config.from, SQL)) {
-              const fromFields = this.getTableLikeFields(this.config.from);
-              fields[tableName] = fromFields;
-            }
-            for (const join of this.config.joins) {
-              const tableName2 = getTableLikeName(join.table);
-              if (typeof tableName2 === "string" && !is(join.table, SQL)) {
-                const fromFields = this.getTableLikeFields(join.table);
-                fields[tableName2] = fromFields;
-              }
-            }
-          }
+      onConflictDoUpdate(config) {
+        if (config.where && (config.targetWhere || config.setWhere)) {
+          throw new Error(
+            'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
+          );
         }
-        this.config.returningFields = fields;
-        this.config.returning = orderSelectedFields(fields);
+        const whereSql = config.where ? sql` where ${config.where}` : void 0;
+        const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
+        const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
+        const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
+        let targetColumn = "";
+        targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
+        this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
         return this;
       }
       /** @internal */
       getSQL() {
-        return this.dialect.buildUpdateQuery(this.config);
+        return this.dialect.buildInsertQuery(this.config);
       }
       toSQL() {
         const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
@@ -28297,9 +28552,12 @@ var init_update = __esm({
       }
       /** @internal */
       _prepare(name2) {
-        const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
-        query.joinsNotNullableMap = this.joinsNotNullableMap;
-        return query;
+        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
+          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true, void 0, {
+            type: "insert",
+            tables: extractUsedTable(this.config.table)
+          }, this.cacheConfig);
+        });
       }
       prepare(name2) {
         return this._prepare(name2);
@@ -28324,1010 +28582,891 @@ var init_update = __esm({
         return this;
       }
     };
-    __publicField(PgUpdateBase, _a138, "PgUpdate");
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/query-builders/index.js
-var init_query_builders = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/index.js"() {
-    "use strict";
-    init_delete();
-    init_insert();
-    init_query_builder2();
-    init_refresh_materialized_view();
-    init_select2();
-    init_select_types();
-    init_update();
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/query-builders/count.js
-var _a139, _b104, _c4, _PgCountBuilder, PgCountBuilder;
-var init_count = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/count.js"() {
-    "use strict";
-    init_entity();
-    init_sql();
-    _PgCountBuilder = class _PgCountBuilder extends (_c4 = SQL, _b104 = entityKind, _a139 = Symbol.toStringTag, _c4) {
-      constructor(params) {
-        super(_PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
-        __publicField(this, "sql");
-        __publicField(this, "token");
-        __publicField(this, _a139, "PgCountBuilder");
-        __publicField(this, "session");
-        this.params = params;
-        this.mapWith(Number);
-        this.session = params.session;
-        this.sql = _PgCountBuilder.buildCount(
-          params.source,
-          params.filters
-        );
-      }
-      static buildEmbeddedCount(source, filters) {
-        return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
-      }
-      static buildCount(source, filters) {
-        return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters};`;
-      }
-      /** @intrnal */
-      setToken(token) {
-        this.token = token;
-        return this;
-      }
-      then(onfulfilled, onrejected) {
-        return Promise.resolve(this.session.count(this.sql, this.token)).then(
-          onfulfilled,
-          onrejected
-        );
-      }
-      catch(onRejected) {
-        return this.then(void 0, onRejected);
-      }
-      finally(onFinally) {
-        return this.then(
-          (value) => {
-            onFinally?.();
-            return value;
-          },
-          (reason) => {
-            onFinally?.();
-            throw reason;
-          }
-        );
-      }
-    };
-    __publicField(_PgCountBuilder, _b104, "PgCountBuilder");
-    PgCountBuilder = _PgCountBuilder;
+    __publicField(PgInsertBase, _a147, "PgInsert");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/query-builders/query.js
-var _a140, RelationalQueryBuilder, _a141, _b105, PgRelationalQuery;
-var init_query = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/query.js"() {
+// ../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js
+var _a148, _b108, PgRefreshMaterializedView;
+var init_refresh_materialized_view = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js"() {
     "use strict";
     init_entity();
     init_query_promise();
-    init_relations();
     init_tracing();
-    _a140 = entityKind;
-    RelationalQueryBuilder = class {
-      constructor(fullSchema, schema5, tableNamesMap, table5, tableConfig, dialect6, session) {
-        this.fullSchema = fullSchema;
-        this.schema = schema5;
-        this.tableNamesMap = tableNamesMap;
-        this.table = table5;
-        this.tableConfig = tableConfig;
-        this.dialect = dialect6;
+    PgRefreshMaterializedView = class extends (_b108 = QueryPromise, _a148 = entityKind, _b108) {
+      constructor(view4, session, dialect6) {
+        super();
+        __publicField(this, "config");
+        __publicField(this, "authToken");
+        __publicField(this, "execute", (placeholderValues) => {
+          return tracer.startActiveSpan("drizzle.operation", () => {
+            return this._prepare().execute(placeholderValues, this.authToken);
+          });
+        });
         this.session = session;
+        this.dialect = dialect6;
+        this.config = { view: view4 };
       }
-      findMany(config) {
-        return new PgRelationalQuery(
-          this.fullSchema,
-          this.schema,
-          this.tableNamesMap,
-          this.table,
-          this.tableConfig,
-          this.dialect,
-          this.session,
-          config ? config : {},
-          "many"
-        );
+      concurrently() {
+        if (this.config.withNoData !== void 0) {
+          throw new Error("Cannot use concurrently and withNoData together");
+        }
+        this.config.concurrently = true;
+        return this;
       }
-      findFirst(config) {
-        return new PgRelationalQuery(
-          this.fullSchema,
-          this.schema,
-          this.tableNamesMap,
-          this.table,
-          this.tableConfig,
-          this.dialect,
-          this.session,
-          config ? { ...config, limit: 1 } : { limit: 1 },
-          "first"
-        );
+      withNoData() {
+        if (this.config.concurrently !== void 0) {
+          throw new Error("Cannot use concurrently and withNoData together");
+        }
+        this.config.withNoData = true;
+        return this;
       }
-    };
-    __publicField(RelationalQueryBuilder, _a140, "PgRelationalQueryBuilder");
-    PgRelationalQuery = class extends (_b105 = QueryPromise, _a141 = entityKind, _b105) {
-      constructor(fullSchema, schema5, tableNamesMap, table5, tableConfig, dialect6, session, config, mode) {
-        super();
-        __publicField(this, "authToken");
-        this.fullSchema = fullSchema;
-        this.schema = schema5;
-        this.tableNamesMap = tableNamesMap;
-        this.table = table5;
-        this.tableConfig = tableConfig;
-        this.dialect = dialect6;
-        this.session = session;
-        this.config = config;
-        this.mode = mode;
+      /** @internal */
+      getSQL() {
+        return this.dialect.buildRefreshMaterializedViewQuery(this.config);
+      }
+      toSQL() {
+        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+        return rest;
       }
       /** @internal */
       _prepare(name2) {
         return tracer.startActiveSpan("drizzle.prepareQuery", () => {
-          const { query, builtQuery } = this._toSQL();
-          return this.session.prepareQuery(
-            builtQuery,
-            void 0,
-            name2,
-            true,
-            (rawRows, mapColumnValue) => {
-              const rows = rawRows.map(
-                (row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
-              );
-              if (this.mode === "first") {
-                return rows[0];
-              }
-              return rows;
-            }
-          );
+          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, name2, true);
         });
       }
       prepare(name2) {
         return this._prepare(name2);
       }
-      _getQuery() {
-        return this.dialect.buildRelationalQueryWithoutPK({
-          fullSchema: this.fullSchema,
-          schema: this.schema,
-          tableNamesMap: this.tableNamesMap,
-          table: this.table,
-          tableConfig: this.tableConfig,
-          queryConfig: this.config,
-          tableAlias: this.tableConfig.tsName
-        });
-      }
-      /** @internal */
-      getSQL() {
-        return this._getQuery().sql;
-      }
-      _toSQL() {
-        const query = this._getQuery();
-        const builtQuery = this.dialect.sqlToQuery(query.sql);
-        return { query, builtQuery };
-      }
-      toSQL() {
-        return this._toSQL().builtQuery;
-      }
       /** @internal */
       setToken(token) {
         this.authToken = token;
         return this;
       }
-      execute() {
-        return tracer.startActiveSpan("drizzle.operation", () => {
-          return this._prepare().execute(void 0, this.authToken);
-        });
-      }
     };
-    __publicField(PgRelationalQuery, _a141, "PgRelationalQuery");
+    __publicField(PgRefreshMaterializedView, _a148, "PgRefreshMaterializedView");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/query-builders/raw.js
-var _a142, _b106, PgRaw;
-var init_raw = __esm({
-  "../drizzle-orm/dist/pg-core/query-builders/raw.js"() {
+// ../drizzle-orm/dist/pg-core/query-builders/select.types.js
+var init_select_types = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/select.types.js"() {
     "use strict";
-    init_entity();
-    init_query_promise();
-    PgRaw = class extends (_b106 = QueryPromise, _a142 = entityKind, _b106) {
-      constructor(execute, sql2, query, mapBatchResult) {
-        super();
-        this.execute = execute;
-        this.sql = sql2;
-        this.query = query;
-        this.mapBatchResult = mapBatchResult;
-      }
-      /** @internal */
-      getSQL() {
-        return this.sql;
-      }
-      getQuery() {
-        return this.query;
-      }
-      mapResult(result, isFromBatch) {
-        return isFromBatch ? this.mapBatchResult(result) : result;
-      }
-      _prepare() {
-        return this;
-      }
-      /** @internal */
-      isResponseInArrayMode() {
-        return false;
-      }
-    };
-    __publicField(PgRaw, _a142, "PgRaw");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/db.js
-var _a143, PgDatabase;
-var init_db = __esm({
-  "../drizzle-orm/dist/pg-core/db.js"() {
+// ../drizzle-orm/dist/pg-core/query-builders/update.js
+var _a149, PgUpdateBuilder, _a150, _b109, PgUpdateBase;
+var init_update = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/update.js"() {
     "use strict";
     init_entity();
-    init_query_builders();
+    init_table2();
+    init_query_promise();
     init_selection_proxy();
     init_sql();
     init_subquery();
-    init_count();
-    init_query();
-    init_raw();
-    init_refresh_materialized_view();
-    _a143 = entityKind;
-    PgDatabase = class {
-      constructor(dialect6, session, schema5) {
-        __publicField(this, "query");
-        /**
-         * Creates a subquery that defines a temporary named result set as a CTE.
-         *
-         * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
-         *
-         * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
-         *
-         * @param alias The alias for the subquery.
-         *
-         * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
-         *
-         * @example
-         *
-         * ```ts
-         * // Create a subquery with alias 'sq' and use it in the select query
-         * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
-         *
-         * const result = await db.with(sq).select().from(sq);
-         * ```
-         *
-         * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
-         *
-         * ```ts
-         * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
-         * const sq = db.$with('sq').as(db.select({
-         *   name: sql<string>`upper(${users.name})`.as('name'),
-         * })
-         * .from(users));
-         *
-         * const result = await db.with(sq).select({ name: sq.name }).from(sq);
-         * ```
-         */
-        __publicField(this, "$with", (alias, selection) => {
-          const self2 = this;
-          const as = (qb) => {
-            if (typeof qb === "function") {
-              qb = qb(new QueryBuilder(self2.dialect));
-            }
-            return new Proxy(
-              new WithSubquery(
-                qb.getSQL(),
-                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
-                alias,
-                true
-              ),
-              new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
-            );
-          };
-          return { as };
-        });
+    init_table();
+    init_utils2();
+    init_view_common();
+    init_utils4();
+    _a149 = entityKind;
+    PgUpdateBuilder = class {
+      constructor(table5, session, dialect6, withList) {
         __publicField(this, "authToken");
+        this.table = table5;
+        this.session = session;
         this.dialect = dialect6;
+        this.withList = withList;
+      }
+      setToken(token) {
+        this.authToken = token;
+        return this;
+      }
+      set(values) {
+        return new PgUpdateBase(
+          this.table,
+          mapUpdateSet(this.table, values),
+          this.session,
+          this.dialect,
+          this.withList
+        ).setToken(this.authToken);
+      }
+    };
+    __publicField(PgUpdateBuilder, _a149, "PgUpdateBuilder");
+    PgUpdateBase = class extends (_b109 = QueryPromise, _a150 = entityKind, _b109) {
+      constructor(table5, set, session, dialect6, withList) {
+        super();
+        __publicField(this, "config");
+        __publicField(this, "tableName");
+        __publicField(this, "joinsNotNullableMap");
+        __publicField(this, "cacheConfig");
+        __publicField(this, "leftJoin", this.createJoin("left"));
+        __publicField(this, "rightJoin", this.createJoin("right"));
+        __publicField(this, "innerJoin", this.createJoin("inner"));
+        __publicField(this, "fullJoin", this.createJoin("full"));
+        __publicField(this, "authToken");
+        __publicField(this, "execute", (placeholderValues) => {
+          return this._prepare().execute(placeholderValues, this.authToken);
+        });
         this.session = session;
-        this._ = schema5 ? {
-          schema: schema5.schema,
-          fullSchema: schema5.fullSchema,
-          tableNamesMap: schema5.tableNamesMap,
-          session
-        } : {
-          schema: void 0,
-          fullSchema: {},
-          tableNamesMap: {},
-          session
-        };
-        this.query = {};
-        if (this._.schema) {
-          for (const [tableName, columns] of Object.entries(this._.schema)) {
-            this.query[tableName] = new RelationalQueryBuilder(
-              schema5.fullSchema,
-              this._.schema,
-              this._.tableNamesMap,
-              schema5.fullSchema[tableName],
-              columns,
-              dialect6,
-              session
-            );
-          }
+        this.dialect = dialect6;
+        this.config = { set, table: table5, withList, joins: [] };
+        this.tableName = getTableLikeName(table5);
+        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
+      }
+      from(source) {
+        const src = source;
+        const tableName = getTableLikeName(src);
+        if (typeof tableName === "string") {
+          this.joinsNotNullableMap[tableName] = true;
         }
+        this.config.from = src;
+        return this;
       }
-      $count(source, filters) {
-        return new PgCountBuilder({ source, filters, session: this.session });
+      getTableLikeFields(table5) {
+        if (is(table5, PgTable)) {
+          return table5[Table2.Symbol.Columns];
+        } else if (is(table5, Subquery)) {
+          return table5._.selectedFields;
+        }
+        return table5[ViewBaseConfig].selectedFields;
+      }
+      createJoin(joinType) {
+        return (table5, on) => {
+          const tableName = getTableLikeName(table5);
+          if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
+            throw new Error(`Alias "${tableName}" is already used in this query`);
+          }
+          if (typeof on === "function") {
+            const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;
+            on = on(
+              new Proxy(
+                this.config.table[Table2.Symbol.Columns],
+                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+              ),
+              from && new Proxy(
+                from,
+                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
+              )
+            );
+          }
+          this.config.joins.push({ on, table: table5, joinType, alias: tableName });
+          if (typeof tableName === "string") {
+            switch (joinType) {
+              case "left": {
+                this.joinsNotNullableMap[tableName] = false;
+                break;
+              }
+              case "right": {
+                this.joinsNotNullableMap = Object.fromEntries(
+                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
+                );
+                this.joinsNotNullableMap[tableName] = true;
+                break;
+              }
+              case "inner": {
+                this.joinsNotNullableMap[tableName] = true;
+                break;
+              }
+              case "full": {
+                this.joinsNotNullableMap = Object.fromEntries(
+                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
+                );
+                this.joinsNotNullableMap[tableName] = false;
+                break;
+              }
+            }
+          }
+          return this;
+        };
       }
       /**
-       * Incorporates a previously defined CTE (using `$with`) into the main query.
+       * Adds a 'where' clause to the query.
        *
-       * This method allows the main query to reference a temporary named result set.
+       * Calling this method will update only those rows that fulfill a specified condition.
        *
-       * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+       * See docs: {@link https://orm.drizzle.team/docs/update}
        *
-       * @param queries The CTEs to incorporate into the main query.
+       * @param where the 'where' clause.
        *
        * @example
+       * You can use conditional operators and `sql function` to filter the rows to be updated.
        *
        * ```ts
-       * // Define a subquery 'sq' as a CTE using $with
-       * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+       * // Update all cars with green color
+       * await db.update(cars).set({ color: 'red' })
+       *   .where(eq(cars.color, 'green'));
+       * // or
+       * await db.update(cars).set({ color: 'red' })
+       *   .where(sql`${cars.color} = 'green'`)
+       * ```
        *
-       * // Incorporate the CTE 'sq' into the main query and select from it
-       * const result = await db.with(sq).select().from(sq);
+       * You can logically combine conditional operators with `and()` and `or()` operators:
+       *
+       * ```ts
+       * // Update all BMW cars with a green color
+       * await db.update(cars).set({ color: 'red' })
+       *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
+       *
+       * // Update all cars with the green or blue color
+       * await db.update(cars).set({ color: 'red' })
+       *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
        * ```
        */
-      with(...queries) {
-        const self2 = this;
-        function select(fields) {
-          return new PgSelectBuilder({
-            fields: fields ?? void 0,
-            session: self2.session,
-            dialect: self2.dialect,
-            withList: queries
-          });
-        }
-        function selectDistinct(fields) {
-          return new PgSelectBuilder({
-            fields: fields ?? void 0,
-            session: self2.session,
-            dialect: self2.dialect,
-            withList: queries,
-            distinct: true
-          });
-        }
-        function selectDistinctOn(on, fields) {
-          return new PgSelectBuilder({
-            fields: fields ?? void 0,
-            session: self2.session,
-            dialect: self2.dialect,
-            withList: queries,
-            distinct: { on }
-          });
-        }
-        function update(table5) {
-          return new PgUpdateBuilder(table5, self2.session, self2.dialect, queries);
-        }
-        function insert(table5) {
-          return new PgInsertBuilder(table5, self2.session, self2.dialect, queries);
-        }
-        function delete_(table5) {
-          return new PgDeleteBase(table5, self2.session, self2.dialect, queries);
-        }
-        return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
+      where(where) {
+        this.config.where = where;
+        return this;
       }
-      select(fields) {
-        return new PgSelectBuilder({
-          fields: fields ?? void 0,
-          session: this.session,
-          dialect: this.dialect
-        });
-      }
-      selectDistinct(fields) {
-        return new PgSelectBuilder({
-          fields: fields ?? void 0,
-          session: this.session,
-          dialect: this.dialect,
-          distinct: true
-        });
+      returning(fields) {
+        if (!fields) {
+          fields = Object.assign({}, this.config.table[Table2.Symbol.Columns]);
+          if (this.config.from) {
+            const tableName = getTableLikeName(this.config.from);
+            if (typeof tableName === "string" && this.config.from && !is(this.config.from, SQL)) {
+              const fromFields = this.getTableLikeFields(this.config.from);
+              fields[tableName] = fromFields;
+            }
+            for (const join of this.config.joins) {
+              const tableName2 = getTableLikeName(join.table);
+              if (typeof tableName2 === "string" && !is(join.table, SQL)) {
+                const fromFields = this.getTableLikeFields(join.table);
+                fields[tableName2] = fromFields;
+              }
+            }
+          }
+        }
+        this.config.returningFields = fields;
+        this.config.returning = orderSelectedFields(fields);
+        return this;
       }
-      selectDistinctOn(on, fields) {
-        return new PgSelectBuilder({
-          fields: fields ?? void 0,
-          session: this.session,
-          dialect: this.dialect,
-          distinct: { on }
-        });
+      /** @internal */
+      getSQL() {
+        return this.dialect.buildUpdateQuery(this.config);
       }
-      /**
-       * Creates an update query.
-       *
-       * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
-       *
-       * Use `.set()` method to specify which values to update.
-       *
-       * See docs: {@link https://orm.drizzle.team/docs/update}
-       *
-       * @param table The table to update.
-       *
-       * @example
-       *
-       * ```ts
-       * // Update all rows in the 'cars' table
-       * await db.update(cars).set({ color: 'red' });
-       *
-       * // Update rows with filters and conditions
-       * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
-       *
-       * // Update with returning clause
-       * const updatedCar: Car[] = await db.update(cars)
-       *   .set({ color: 'red' })
-       *   .where(eq(cars.id, 1))
-       *   .returning();
-       * ```
-       */
-      update(table5) {
-        return new PgUpdateBuilder(table5, this.session, this.dialect);
+      toSQL() {
+        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
+        return rest;
       }
-      /**
-       * Creates an insert query.
-       *
-       * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
-       *
-       * See docs: {@link https://orm.drizzle.team/docs/insert}
-       *
-       * @param table The table to insert into.
-       *
-       * @example
-       *
-       * ```ts
-       * // Insert one row
-       * await db.insert(cars).values({ brand: 'BMW' });
-       *
-       * // Insert multiple rows
-       * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
-       *
-       * // Insert with returning clause
-       * const insertedCar: Car[] = await db.insert(cars)
-       *   .values({ brand: 'BMW' })
-       *   .returning();
-       * ```
-       */
-      insert(table5) {
-        return new PgInsertBuilder(table5, this.session, this.dialect);
+      /** @internal */
+      _prepare(name2) {
+        const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true, void 0, {
+          type: "insert",
+          tables: extractUsedTable(this.config.table)
+        }, this.cacheConfig);
+        query.joinsNotNullableMap = this.joinsNotNullableMap;
+        return query;
       }
-      /**
-       * Creates a delete query.
-       *
-       * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
-       *
-       * See docs: {@link https://orm.drizzle.team/docs/delete}
-       *
-       * @param table The table to delete from.
-       *
-       * @example
-       *
-       * ```ts
-       * // Delete all rows in the 'cars' table
-       * await db.delete(cars);
-       *
-       * // Delete rows with filters and conditions
-       * await db.delete(cars).where(eq(cars.color, 'green'));
-       *
-       * // Delete with returning clause
-       * const deletedCar: Car[] = await db.delete(cars)
-       *   .where(eq(cars.id, 1))
-       *   .returning();
-       * ```
-       */
-      delete(table5) {
-        return new PgDeleteBase(table5, this.session, this.dialect);
+      prepare(name2) {
+        return this._prepare(name2);
       }
-      refreshMaterializedView(view4) {
-        return new PgRefreshMaterializedView(view4, this.session, this.dialect);
+      /** @internal */
+      setToken(token) {
+        this.authToken = token;
+        return this;
       }
-      execute(query) {
-        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
-        const builtQuery = this.dialect.sqlToQuery(sequel);
-        const prepared = this.session.prepareQuery(
-          builtQuery,
-          void 0,
-          void 0,
-          false
-        );
-        return new PgRaw(
-          () => prepared.execute(void 0, this.authToken),
-          sequel,
-          builtQuery,
-          (result) => prepared.mapResult(result, true)
-        );
+      /** @internal */
+      getSelectedFields() {
+        return this.config.returningFields ? new Proxy(
+          this.config.returningFields,
+          new SelectionProxyHandler({
+            alias: getTableName(this.config.table),
+            sqlAliasedBehavior: "alias",
+            sqlBehavior: "error"
+          })
+        ) : void 0;
       }
-      transaction(transaction, config) {
-        return this.session.transaction(transaction, config);
+      $dynamic() {
+        return this;
       }
     };
-    __publicField(PgDatabase, _a143, "PgDatabase");
+    __publicField(PgUpdateBase, _a150, "PgUpdate");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/indexes.js
-var _a144, IndexBuilderOn, _a145, IndexBuilder, _a146, Index2;
-var init_indexes = __esm({
-  "../drizzle-orm/dist/pg-core/indexes.js"() {
+// ../drizzle-orm/dist/pg-core/query-builders/index.js
+var init_query_builders = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/index.js"() {
+    "use strict";
+    init_delete();
+    init_insert();
+    init_query_builder2();
+    init_refresh_materialized_view();
+    init_select2();
+    init_select_types();
+    init_update();
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/query-builders/count.js
+var _a151, _b110, _c6, _PgCountBuilder, PgCountBuilder;
+var init_count = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/count.js"() {
     "use strict";
-    init_sql();
     init_entity();
-    init_columns();
-    _a144 = entityKind;
-    IndexBuilderOn = class {
-      constructor(unique, name2) {
-        this.unique = unique;
-        this.name = name2;
-      }
-      on(...columns) {
-        return new IndexBuilder(
-          columns.map((it) => {
-            if (is(it, SQL)) {
-              return it;
-            }
-            it = it;
-            const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
-            it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
-            return clonedIndexedColumn;
-          }),
-          this.unique,
-          false,
-          this.name
+    init_sql();
+    _PgCountBuilder = class _PgCountBuilder extends (_c6 = SQL, _b110 = entityKind, _a151 = Symbol.toStringTag, _c6) {
+      constructor(params) {
+        super(_PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
+        __publicField(this, "sql");
+        __publicField(this, "token");
+        __publicField(this, _a151, "PgCountBuilder");
+        __publicField(this, "session");
+        this.params = params;
+        this.mapWith(Number);
+        this.session = params.session;
+        this.sql = _PgCountBuilder.buildCount(
+          params.source,
+          params.filters
         );
       }
-      onOnly(...columns) {
-        return new IndexBuilder(
-          columns.map((it) => {
-            if (is(it, SQL)) {
-              return it;
-            }
-            it = it;
-            const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
-            it.indexConfig = it.defaultConfig;
-            return clonedIndexedColumn;
-          }),
-          this.unique,
-          true,
-          this.name
+      static buildEmbeddedCount(source, filters) {
+        return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
+      }
+      static buildCount(source, filters) {
+        return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters};`;
+      }
+      /** @intrnal */
+      setToken(token) {
+        this.token = token;
+        return this;
+      }
+      then(onfulfilled, onrejected) {
+        return Promise.resolve(this.session.count(this.sql, this.token)).then(
+          onfulfilled,
+          onrejected
         );
       }
-      /**
-       * Specify what index method to use. Choices are `btree`, `hash`, `gist`, `spgist`, `gin`, `brin`, or user-installed access methods like `bloom`. The default method is `btree.
-       *
-       * If you have the `pg_vector` extension installed in your database, you can use the `hnsw` and `ivfflat` options, which are predefined types.
-       *
-       * **You can always specify any string you want in the method, in case Drizzle doesn't have it natively in its types**
-       *
-       * @param method The name of the index method to be used
-       * @param columns
-       * @returns
-       */
-      using(method, ...columns) {
-        return new IndexBuilder(
-          columns.map((it) => {
-            if (is(it, SQL)) {
-              return it;
-            }
-            it = it;
-            const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
-            it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
-            return clonedIndexedColumn;
-          }),
-          this.unique,
-          true,
-          this.name,
-          method
+      catch(onRejected) {
+        return this.then(void 0, onRejected);
+      }
+      finally(onFinally) {
+        return this.then(
+          (value) => {
+            onFinally?.();
+            return value;
+          },
+          (reason) => {
+            onFinally?.();
+            throw reason;
+          }
         );
       }
     };
-    __publicField(IndexBuilderOn, _a144, "PgIndexBuilderOn");
-    _a145 = entityKind;
-    IndexBuilder = class {
-      constructor(columns, unique, only, name2, method = "btree") {
-        /** @internal */
-        __publicField(this, "config");
-        this.config = {
-          name: name2,
-          columns,
-          unique,
-          only,
-          method
-        };
+    __publicField(_PgCountBuilder, _b110, "PgCountBuilder");
+    PgCountBuilder = _PgCountBuilder;
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/query-builders/query.js
+var _a152, RelationalQueryBuilder, _a153, _b111, PgRelationalQuery;
+var init_query = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/query.js"() {
+    "use strict";
+    init_entity();
+    init_query_promise();
+    init_relations();
+    init_tracing();
+    _a152 = entityKind;
+    RelationalQueryBuilder = class {
+      constructor(fullSchema, schema5, tableNamesMap, table5, tableConfig, dialect6, session) {
+        this.fullSchema = fullSchema;
+        this.schema = schema5;
+        this.tableNamesMap = tableNamesMap;
+        this.table = table5;
+        this.tableConfig = tableConfig;
+        this.dialect = dialect6;
+        this.session = session;
       }
-      concurrently() {
-        this.config.concurrently = true;
-        return this;
+      findMany(config) {
+        return new PgRelationalQuery(
+          this.fullSchema,
+          this.schema,
+          this.tableNamesMap,
+          this.table,
+          this.tableConfig,
+          this.dialect,
+          this.session,
+          config ? config : {},
+          "many"
+        );
       }
-      with(obj) {
-        this.config.with = obj;
-        return this;
+      findFirst(config) {
+        return new PgRelationalQuery(
+          this.fullSchema,
+          this.schema,
+          this.tableNamesMap,
+          this.table,
+          this.tableConfig,
+          this.dialect,
+          this.session,
+          config ? { ...config, limit: 1 } : { limit: 1 },
+          "first"
+        );
       }
-      where(condition) {
-        this.config.where = condition;
-        return this;
+    };
+    __publicField(RelationalQueryBuilder, _a152, "PgRelationalQueryBuilder");
+    PgRelationalQuery = class extends (_b111 = QueryPromise, _a153 = entityKind, _b111) {
+      constructor(fullSchema, schema5, tableNamesMap, table5, tableConfig, dialect6, session, config, mode) {
+        super();
+        __publicField(this, "authToken");
+        this.fullSchema = fullSchema;
+        this.schema = schema5;
+        this.tableNamesMap = tableNamesMap;
+        this.table = table5;
+        this.tableConfig = tableConfig;
+        this.dialect = dialect6;
+        this.session = session;
+        this.config = config;
+        this.mode = mode;
       }
       /** @internal */
-      build(table5) {
-        return new Index2(this.config, table5);
+      _prepare(name2) {
+        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
+          const { query, builtQuery } = this._toSQL();
+          return this.session.prepareQuery(
+            builtQuery,
+            void 0,
+            name2,
+            true,
+            (rawRows, mapColumnValue) => {
+              const rows = rawRows.map(
+                (row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
+              );
+              if (this.mode === "first") {
+                return rows[0];
+              }
+              return rows;
+            }
+          );
+        });
       }
-    };
-    __publicField(IndexBuilder, _a145, "PgIndexBuilder");
-    _a146 = entityKind;
-    Index2 = class {
-      constructor(config, table5) {
-        __publicField(this, "config");
-        this.config = { ...config, table: table5 };
+      prepare(name2) {
+        return this._prepare(name2);
       }
-    };
-    __publicField(Index2, _a146, "PgIndex");
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/policies.js
-var _a147, PgPolicy;
-var init_policies = __esm({
-  "../drizzle-orm/dist/pg-core/policies.js"() {
-    "use strict";
-    init_entity();
-    _a147 = entityKind;
-    PgPolicy = class {
-      constructor(name2, config) {
-        __publicField(this, "as");
-        __publicField(this, "for");
-        __publicField(this, "to");
-        __publicField(this, "using");
-        __publicField(this, "withCheck");
-        /** @internal */
-        __publicField(this, "_linkedTable");
-        this.name = name2;
-        if (config) {
-          this.as = config.as;
-          this.for = config.for;
-          this.to = config.to;
-          this.using = config.using;
-          this.withCheck = config.withCheck;
-        }
+      _getQuery() {
+        return this.dialect.buildRelationalQueryWithoutPK({
+          fullSchema: this.fullSchema,
+          schema: this.schema,
+          tableNamesMap: this.tableNamesMap,
+          table: this.table,
+          tableConfig: this.tableConfig,
+          queryConfig: this.config,
+          tableAlias: this.tableConfig.tsName
+        });
       }
-      link(table5) {
-        this._linkedTable = table5;
+      /** @internal */
+      getSQL() {
+        return this._getQuery().sql;
+      }
+      _toSQL() {
+        const query = this._getQuery();
+        const builtQuery = this.dialect.sqlToQuery(query.sql);
+        return { query, builtQuery };
+      }
+      toSQL() {
+        return this._toSQL().builtQuery;
+      }
+      /** @internal */
+      setToken(token) {
+        this.authToken = token;
         return this;
       }
+      execute() {
+        return tracer.startActiveSpan("drizzle.operation", () => {
+          return this._prepare().execute(void 0, this.authToken);
+        });
+      }
     };
-    __publicField(PgPolicy, _a147, "PgPolicy");
+    __publicField(PgRelationalQuery, _a153, "PgRelationalQuery");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/roles.js
-var _a148, PgRole;
-var init_roles = __esm({
-  "../drizzle-orm/dist/pg-core/roles.js"() {
+// ../drizzle-orm/dist/pg-core/query-builders/raw.js
+var _a154, _b112, PgRaw;
+var init_raw = __esm({
+  "../drizzle-orm/dist/pg-core/query-builders/raw.js"() {
     "use strict";
     init_entity();
-    _a148 = entityKind;
-    PgRole = class {
-      constructor(name2, config) {
-        /** @internal */
-        __publicField(this, "_existing");
-        /** @internal */
-        __publicField(this, "createDb");
-        /** @internal */
-        __publicField(this, "createRole");
-        /** @internal */
-        __publicField(this, "inherit");
-        this.name = name2;
-        if (config) {
-          this.createDb = config.createDb;
-          this.createRole = config.createRole;
-          this.inherit = config.inherit;
-        }
+    init_query_promise();
+    PgRaw = class extends (_b112 = QueryPromise, _a154 = entityKind, _b112) {
+      constructor(execute, sql2, query, mapBatchResult) {
+        super();
+        this.execute = execute;
+        this.sql = sql2;
+        this.query = query;
+        this.mapBatchResult = mapBatchResult;
       }
-      existing() {
-        this._existing = true;
+      /** @internal */
+      getSQL() {
+        return this.sql;
+      }
+      getQuery() {
+        return this.query;
+      }
+      mapResult(result, isFromBatch) {
+        return isFromBatch ? this.mapBatchResult(result) : result;
+      }
+      _prepare() {
         return this;
       }
+      /** @internal */
+      isResponseInArrayMode() {
+        return false;
+      }
     };
-    __publicField(PgRole, _a148, "PgRole");
+    __publicField(PgRaw, _a154, "PgRaw");
   }
 });
 
-// ../drizzle-orm/dist/pg-core/sequence.js
-function pgSequenceWithSchema(name2, options, schema5) {
-  return new PgSequence(name2, options, schema5);
-}
-function isPgSequence(obj) {
-  return is(obj, PgSequence);
-}
-var _a149, PgSequence;
-var init_sequence = __esm({
-  "../drizzle-orm/dist/pg-core/sequence.js"() {
-    "use strict";
-    init_entity();
-    _a149 = entityKind;
-    PgSequence = class {
-      constructor(seqName, seqOptions, schema5) {
-        this.seqName = seqName;
-        this.seqOptions = seqOptions;
-        this.schema = schema5;
-      }
-    };
-    __publicField(PgSequence, _a149, "PgSequence");
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/view-common.js
-var PgViewConfig;
-var init_view_common2 = __esm({
-  "../drizzle-orm/dist/pg-core/view-common.js"() {
-    "use strict";
-    PgViewConfig = Symbol.for("drizzle:PgViewConfig");
-  }
-});
-
-// ../drizzle-orm/dist/pg-core/view.js
-function pgViewWithSchema(name2, selection, schema5) {
-  if (selection) {
-    return new ManualViewBuilder(name2, selection, schema5);
-  }
-  return new ViewBuilder(name2, schema5);
-}
-function pgMaterializedViewWithSchema(name2, selection, schema5) {
-  if (selection) {
-    return new ManualMaterializedViewBuilder(name2, selection, schema5);
-  }
-  return new MaterializedViewBuilder(name2, schema5);
-}
-function isPgView(obj) {
-  return is(obj, PgView2);
-}
-function isPgMaterializedView(obj) {
-  return is(obj, PgMaterializedView);
-}
-var _a150, DefaultViewBuilderCore, _a151, _b107, ViewBuilder, _a152, _b108, ManualViewBuilder, _a153, MaterializedViewBuilderCore, _a154, _b109, MaterializedViewBuilder, _a155, _b110, ManualMaterializedViewBuilder, _a156, _b111, _c5, PgView2, PgMaterializedViewConfig, _a157, _b112, _c6, PgMaterializedView;
-var init_view = __esm({
-  "../drizzle-orm/dist/pg-core/view.js"() {
+// ../drizzle-orm/dist/pg-core/db.js
+var _a155, PgDatabase;
+var init_db = __esm({
+  "../drizzle-orm/dist/pg-core/db.js"() {
     "use strict";
     init_entity();
+    init_query_builders();
     init_selection_proxy();
-    init_utils2();
-    init_query_builder2();
-    init_table2();
-    init_view_base();
-    init_view_common2();
-    _a150 = entityKind;
-    DefaultViewBuilderCore = class {
-      constructor(name2, schema5) {
-        __publicField(this, "config", {});
-        this.name = name2;
-        this.schema = schema5;
+    init_sql();
+    init_subquery();
+    init_count();
+    init_query();
+    init_raw();
+    init_refresh_materialized_view();
+    _a155 = entityKind;
+    PgDatabase = class {
+      constructor(dialect6, session, schema5) {
+        __publicField(this, "query");
+        /**
+         * Creates a subquery that defines a temporary named result set as a CTE.
+         *
+         * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
+         *
+         * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+         *
+         * @param alias The alias for the subquery.
+         *
+         * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
+         *
+         * @example
+         *
+         * ```ts
+         * // Create a subquery with alias 'sq' and use it in the select query
+         * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+         *
+         * const result = await db.with(sq).select().from(sq);
+         * ```
+         *
+         * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
+         *
+         * ```ts
+         * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
+         * const sq = db.$with('sq').as(db.select({
+         *   name: sql<string>`upper(${users.name})`.as('name'),
+         * })
+         * .from(users));
+         *
+         * const result = await db.with(sq).select({ name: sq.name }).from(sq);
+         * ```
+         */
+        __publicField(this, "$with", (alias, selection) => {
+          const self2 = this;
+          const as = (qb) => {
+            if (typeof qb === "function") {
+              qb = qb(new QueryBuilder(self2.dialect));
+            }
+            return new Proxy(
+              new WithSubquery(
+                qb.getSQL(),
+                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
+                alias,
+                true
+              ),
+              new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+            );
+          };
+          return { as };
+        });
+        __publicField(this, "$cache");
+        __publicField(this, "authToken");
+        this.dialect = dialect6;
+        this.session = session;
+        this._ = schema5 ? {
+          schema: schema5.schema,
+          fullSchema: schema5.fullSchema,
+          tableNamesMap: schema5.tableNamesMap,
+          session
+        } : {
+          schema: void 0,
+          fullSchema: {},
+          tableNamesMap: {},
+          session
+        };
+        this.query = {};
+        if (this._.schema) {
+          for (const [tableName, columns] of Object.entries(this._.schema)) {
+            this.query[tableName] = new RelationalQueryBuilder(
+              schema5.fullSchema,
+              this._.schema,
+              this._.tableNamesMap,
+              schema5.fullSchema[tableName],
+              columns,
+              dialect6,
+              session
+            );
+          }
+        }
       }
-      with(config) {
-        this.config.with = config;
-        return this;
+      $count(source, filters) {
+        return new PgCountBuilder({ source, filters, session: this.session });
       }
-    };
-    __publicField(DefaultViewBuilderCore, _a150, "PgDefaultViewBuilderCore");
-    ViewBuilder = class extends (_b107 = DefaultViewBuilderCore, _a151 = entityKind, _b107) {
-      as(qb) {
-        if (typeof qb === "function") {
-          qb = qb(new QueryBuilder());
+      /**
+       * Incorporates a previously defined CTE (using `$with`) into the main query.
+       *
+       * This method allows the main query to reference a temporary named result set.
+       *
+       * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
+       *
+       * @param queries The CTEs to incorporate into the main query.
+       *
+       * @example
+       *
+       * ```ts
+       * // Define a subquery 'sq' as a CTE using $with
+       * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
+       *
+       * // Incorporate the CTE 'sq' into the main query and select from it
+       * const result = await db.with(sq).select().from(sq);
+       * ```
+       */
+      with(...queries) {
+        const self2 = this;
+        function select(fields) {
+          return new PgSelectBuilder({
+            fields: fields ?? void 0,
+            session: self2.session,
+            dialect: self2.dialect,
+            withList: queries
+          });
         }
-        const selectionProxy = new SelectionProxyHandler({
-          alias: this.name,
-          sqlBehavior: "error",
-          sqlAliasedBehavior: "alias",
-          replaceOriginalName: true
-        });
-        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
-        return new Proxy(
-          new PgView2({
-            pgConfig: this.config,
-            config: {
-              name: this.name,
-              schema: this.schema,
-              selectedFields: aliasedSelection,
-              query: qb.getSQL().inlineParams()
-            }
-          }),
-          selectionProxy
-        );
-      }
-    };
-    __publicField(ViewBuilder, _a151, "PgViewBuilder");
-    ManualViewBuilder = class extends (_b108 = DefaultViewBuilderCore, _a152 = entityKind, _b108) {
-      constructor(name2, columns, schema5) {
-        super(name2, schema5);
-        __publicField(this, "columns");
-        this.columns = getTableColumns(pgTable(name2, columns));
+        function selectDistinct(fields) {
+          return new PgSelectBuilder({
+            fields: fields ?? void 0,
+            session: self2.session,
+            dialect: self2.dialect,
+            withList: queries,
+            distinct: true
+          });
+        }
+        function selectDistinctOn(on, fields) {
+          return new PgSelectBuilder({
+            fields: fields ?? void 0,
+            session: self2.session,
+            dialect: self2.dialect,
+            withList: queries,
+            distinct: { on }
+          });
+        }
+        function update(table5) {
+          return new PgUpdateBuilder(table5, self2.session, self2.dialect, queries);
+        }
+        function insert(table5) {
+          return new PgInsertBuilder(table5, self2.session, self2.dialect, queries);
+        }
+        function delete_(table5) {
+          return new PgDeleteBase(table5, self2.session, self2.dialect, queries);
+        }
+        return { select, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
       }
-      existing() {
-        return new Proxy(
-          new PgView2({
-            pgConfig: void 0,
-            config: {
-              name: this.name,
-              schema: this.schema,
-              selectedFields: this.columns,
-              query: void 0
-            }
-          }),
-          new SelectionProxyHandler({
-            alias: this.name,
-            sqlBehavior: "error",
-            sqlAliasedBehavior: "alias",
-            replaceOriginalName: true
-          })
-        );
+      select(fields) {
+        return new PgSelectBuilder({
+          fields: fields ?? void 0,
+          session: this.session,
+          dialect: this.dialect
+        });
       }
-      as(query) {
-        return new Proxy(
-          new PgView2({
-            pgConfig: this.config,
-            config: {
-              name: this.name,
-              schema: this.schema,
-              selectedFields: this.columns,
-              query: query.inlineParams()
-            }
-          }),
-          new SelectionProxyHandler({
-            alias: this.name,
-            sqlBehavior: "error",
-            sqlAliasedBehavior: "alias",
-            replaceOriginalName: true
-          })
-        );
+      selectDistinct(fields) {
+        return new PgSelectBuilder({
+          fields: fields ?? void 0,
+          session: this.session,
+          dialect: this.dialect,
+          distinct: true
+        });
       }
-    };
-    __publicField(ManualViewBuilder, _a152, "PgManualViewBuilder");
-    _a153 = entityKind;
-    MaterializedViewBuilderCore = class {
-      constructor(name2, schema5) {
-        __publicField(this, "config", {});
-        this.name = name2;
-        this.schema = schema5;
+      selectDistinctOn(on, fields) {
+        return new PgSelectBuilder({
+          fields: fields ?? void 0,
+          session: this.session,
+          dialect: this.dialect,
+          distinct: { on }
+        });
       }
-      using(using) {
-        this.config.using = using;
-        return this;
+      /**
+       * Creates an update query.
+       *
+       * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
+       *
+       * Use `.set()` method to specify which values to update.
+       *
+       * See docs: {@link https://orm.drizzle.team/docs/update}
+       *
+       * @param table The table to update.
+       *
+       * @example
+       *
+       * ```ts
+       * // Update all rows in the 'cars' table
+       * await db.update(cars).set({ color: 'red' });
+       *
+       * // Update rows with filters and conditions
+       * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
+       *
+       * // Update with returning clause
+       * const updatedCar: Car[] = await db.update(cars)
+       *   .set({ color: 'red' })
+       *   .where(eq(cars.id, 1))
+       *   .returning();
+       * ```
+       */
+      update(table5) {
+        return new PgUpdateBuilder(table5, this.session, this.dialect);
       }
-      with(config) {
-        this.config.with = config;
-        return this;
+      /**
+       * Creates an insert query.
+       *
+       * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
+       *
+       * See docs: {@link https://orm.drizzle.team/docs/insert}
+       *
+       * @param table The table to insert into.
+       *
+       * @example
+       *
+       * ```ts
+       * // Insert one row
+       * await db.insert(cars).values({ brand: 'BMW' });
+       *
+       * // Insert multiple rows
+       * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
+       *
+       * // Insert with returning clause
+       * const insertedCar: Car[] = await db.insert(cars)
+       *   .values({ brand: 'BMW' })
+       *   .returning();
+       * ```
+       */
+      insert(table5) {
+        return new PgInsertBuilder(table5, this.session, this.dialect);
       }
-      tablespace(tablespace) {
-        this.config.tablespace = tablespace;
-        return this;
+      /**
+       * Creates a delete query.
+       *
+       * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
+       *
+       * See docs: {@link https://orm.drizzle.team/docs/delete}
+       *
+       * @param table The table to delete from.
+       *
+       * @example
+       *
+       * ```ts
+       * // Delete all rows in the 'cars' table
+       * await db.delete(cars);
+       *
+       * // Delete rows with filters and conditions
+       * await db.delete(cars).where(eq(cars.color, 'green'));
+       *
+       * // Delete with returning clause
+       * const deletedCar: Car[] = await db.delete(cars)
+       *   .where(eq(cars.id, 1))
+       *   .returning();
+       * ```
+       */
+      delete(table5) {
+        return new PgDeleteBase(table5, this.session, this.dialect);
       }
-      withNoData() {
-        this.config.withNoData = true;
-        return this;
+      refreshMaterializedView(view4) {
+        return new PgRefreshMaterializedView(view4, this.session, this.dialect);
       }
-    };
-    __publicField(MaterializedViewBuilderCore, _a153, "PgMaterializedViewBuilderCore");
-    MaterializedViewBuilder = class extends (_b109 = MaterializedViewBuilderCore, _a154 = entityKind, _b109) {
-      as(qb) {
-        if (typeof qb === "function") {
-          qb = qb(new QueryBuilder());
-        }
-        const selectionProxy = new SelectionProxyHandler({
-          alias: this.name,
-          sqlBehavior: "error",
-          sqlAliasedBehavior: "alias",
-          replaceOriginalName: true
-        });
-        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
-        return new Proxy(
-          new PgMaterializedView({
-            pgConfig: {
-              with: this.config.with,
-              using: this.config.using,
-              tablespace: this.config.tablespace,
-              withNoData: this.config.withNoData
-            },
-            config: {
-              name: this.name,
-              schema: this.schema,
-              selectedFields: aliasedSelection,
-              query: qb.getSQL().inlineParams()
-            }
-          }),
-          selectionProxy
+      execute(query) {
+        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
+        const builtQuery = this.dialect.sqlToQuery(sequel);
+        const prepared = this.session.prepareQuery(
+          builtQuery,
+          void 0,
+          void 0,
+          false
         );
-      }
-    };
-    __publicField(MaterializedViewBuilder, _a154, "PgMaterializedViewBuilder");
-    ManualMaterializedViewBuilder = class extends (_b110 = MaterializedViewBuilderCore, _a155 = entityKind, _b110) {
-      constructor(name2, columns, schema5) {
-        super(name2, schema5);
-        __publicField(this, "columns");
-        this.columns = getTableColumns(pgTable(name2, columns));
-      }
-      existing() {
-        return new Proxy(
-          new PgMaterializedView({
-            pgConfig: {
-              tablespace: this.config.tablespace,
-              using: this.config.using,
-              with: this.config.with,
-              withNoData: this.config.withNoData
-            },
-            config: {
-              name: this.name,
-              schema: this.schema,
-              selectedFields: this.columns,
-              query: void 0
-            }
-          }),
-          new SelectionProxyHandler({
-            alias: this.name,
-            sqlBehavior: "error",
-            sqlAliasedBehavior: "alias",
-            replaceOriginalName: true
-          })
+        return new PgRaw(
+          () => prepared.execute(void 0, this.authToken),
+          sequel,
+          builtQuery,
+          (result) => prepared.mapResult(result, true)
         );
       }
-      as(query) {
-        return new Proxy(
-          new PgMaterializedView({
-            pgConfig: {
-              tablespace: this.config.tablespace,
-              using: this.config.using,
-              with: this.config.with,
-              withNoData: this.config.withNoData
-            },
-            config: {
-              name: this.name,
-              schema: this.schema,
-              selectedFields: this.columns,
-              query: query.inlineParams()
-            }
-          }),
-          new SelectionProxyHandler({
-            alias: this.name,
-            sqlBehavior: "error",
-            sqlAliasedBehavior: "alias",
-            replaceOriginalName: true
-          })
-        );
+      transaction(transaction, config) {
+        return this.session.transaction(transaction, config);
       }
     };
-    __publicField(ManualMaterializedViewBuilder, _a155, "PgManualMaterializedViewBuilder");
-    PgView2 = class extends (_c5 = PgViewBase, _b111 = entityKind, _a156 = PgViewConfig, _c5) {
-      constructor({ pgConfig, config }) {
-        super(config);
-        __publicField(this, _a156);
-        if (pgConfig) {
-          this[PgViewConfig] = {
-            with: pgConfig.with
-          };
+    __publicField(PgDatabase, _a155, "PgDatabase");
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/roles.js
+var _a156, PgRole;
+var init_roles = __esm({
+  "../drizzle-orm/dist/pg-core/roles.js"() {
+    "use strict";
+    init_entity();
+    _a156 = entityKind;
+    PgRole = class {
+      constructor(name2, config) {
+        /** @internal */
+        __publicField(this, "_existing");
+        /** @internal */
+        __publicField(this, "createDb");
+        /** @internal */
+        __publicField(this, "createRole");
+        /** @internal */
+        __publicField(this, "inherit");
+        this.name = name2;
+        if (config) {
+          this.createDb = config.createDb;
+          this.createRole = config.createRole;
+          this.inherit = config.inherit;
         }
       }
+      existing() {
+        this._existing = true;
+        return this;
+      }
     };
-    __publicField(PgView2, _b111, "PgView");
-    PgMaterializedViewConfig = Symbol.for("drizzle:PgMaterializedViewConfig");
-    PgMaterializedView = class extends (_c6 = PgViewBase, _b112 = entityKind, _a157 = PgMaterializedViewConfig, _c6) {
-      constructor({ pgConfig, config }) {
-        super(config);
-        __publicField(this, _a157);
-        this[PgMaterializedViewConfig] = {
-          with: pgConfig?.with,
-          using: pgConfig?.using,
-          tablespace: pgConfig?.tablespace,
-          withNoData: pgConfig?.withNoData
-        };
+    __publicField(PgRole, _a156, "PgRole");
+  }
+});
+
+// ../drizzle-orm/dist/pg-core/sequence.js
+function pgSequenceWithSchema(name2, options, schema5) {
+  return new PgSequence(name2, options, schema5);
+}
+function isPgSequence(obj) {
+  return is(obj, PgSequence);
+}
+var _a157, PgSequence;
+var init_sequence = __esm({
+  "../drizzle-orm/dist/pg-core/sequence.js"() {
+    "use strict";
+    init_entity();
+    _a157 = entityKind;
+    PgSequence = class {
+      constructor(seqName, seqOptions, schema5) {
+        this.seqName = seqName;
+        this.seqOptions = seqOptions;
+        this.schema = schema5;
       }
     };
-    __publicField(PgMaterializedView, _b112, "PgMaterializedView");
+    __publicField(PgSequence, _a157, "PgSequence");
   }
 });
 
@@ -29385,11 +29524,20 @@ var init_session = __esm({
     init_db();
     _a159 = entityKind;
     PgPreparedQuery = class {
-      constructor(query) {
+      constructor(query, cache, queryMetadata, cacheConfig) {
         __publicField(this, "authToken");
         /** @internal */
         __publicField(this, "joinsNotNullableMap");
         this.query = query;
+        this.cache = cache;
+        this.queryMetadata = queryMetadata;
+        this.cacheConfig = cacheConfig;
+        if (cache && cache.strategy() === "all" && cacheConfig === void 0) {
+          this.cacheConfig = { enable: true, autoInvalidate: true };
+        }
+        if (!this.cacheConfig?.enable) {
+          this.cacheConfig = void 0;
+        }
       }
       getQuery() {
         return this.query;
@@ -29402,6 +29550,49 @@ var init_session = __esm({
         this.authToken = token;
         return this;
       }
+      async hashQuery(sql2, params) {
+        const dataToHash = `${sql2}-${JSON.stringify(params)}`;
+        const encoder = new TextEncoder();
+        const data = encoder.encode(dataToHash);
+        const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+        const hashArray = [...new Uint8Array(hashBuffer)];
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        return hashHex;
+      }
+      /** @internal */
+      async queryWithCache(queryString, params, query) {
+        if (this.cache === void 0 || this.queryMetadata === void 0) {
+          return await query();
+        }
+        if (this.cacheConfig && !this.cacheConfig.enable) {
+          return await query();
+        }
+        if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
+          await this.cache.onMutate({ tables: this.queryMetadata.tables });
+        }
+        if (!this.cacheConfig) {
+          return await query();
+        }
+        if (this.queryMetadata.type === "select") {
+          const fromCache = await this.cache.get(
+            this.cacheConfig.tag ?? await this.hashQuery(queryString, params)
+          );
+          if (fromCache === void 0) {
+            console.log("Cache empty. Querying database", queryString);
+            const result = await query();
+            await this.cache.put(
+              this.cacheConfig.tag ?? await this.hashQuery(queryString, params),
+              result,
+              // make sure we send tables that were used in a query only if user wants to invalidate it on each write
+              this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
+              this.cacheConfig.config
+            );
+            return result;
+          }
+          return fromCache;
+        }
+        return await query();
+      }
     };
     __publicField(PgPreparedQuery, _a159, "PgPreparedQuery");
     _a160 = entityKind;
@@ -29478,81 +29669,6 @@ var init_subquery2 = __esm({
   }
 });
 
-// ../drizzle-orm/dist/pg-core/utils.js
-function getTableConfig(table5) {
-  const columns = Object.values(table5[Table2.Symbol.Columns]);
-  const indexes = [];
-  const checks = [];
-  const primaryKeys = [];
-  const foreignKeys = Object.values(table5[PgTable.Symbol.InlineForeignKeys]);
-  const uniqueConstraints = [];
-  const name2 = table5[Table2.Symbol.Name];
-  const schema5 = table5[Table2.Symbol.Schema];
-  const policies = [];
-  const enableRLS = table5[PgTable.Symbol.EnableRLS];
-  const extraConfigBuilder = table5[PgTable.Symbol.ExtraConfigBuilder];
-  if (extraConfigBuilder !== void 0) {
-    const extraConfig = extraConfigBuilder(table5[Table2.Symbol.ExtraConfigColumns]);
-    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
-    for (const builder of extraValues) {
-      if (is(builder, IndexBuilder)) {
-        indexes.push(builder.build(table5));
-      } else if (is(builder, CheckBuilder)) {
-        checks.push(builder.build(table5));
-      } else if (is(builder, UniqueConstraintBuilder)) {
-        uniqueConstraints.push(builder.build(table5));
-      } else if (is(builder, PrimaryKeyBuilder)) {
-        primaryKeys.push(builder.build(table5));
-      } else if (is(builder, ForeignKeyBuilder)) {
-        foreignKeys.push(builder.build(table5));
-      } else if (is(builder, PgPolicy)) {
-        policies.push(builder);
-      }
-    }
-  }
-  return {
-    columns,
-    indexes,
-    foreignKeys,
-    checks,
-    primaryKeys,
-    uniqueConstraints,
-    name: name2,
-    schema: schema5,
-    policies,
-    enableRLS
-  };
-}
-function getViewConfig(view4) {
-  return {
-    ...view4[ViewBaseConfig],
-    ...view4[PgViewConfig]
-  };
-}
-function getMaterializedViewConfig(view4) {
-  return {
-    ...view4[ViewBaseConfig],
-    ...view4[PgMaterializedViewConfig]
-  };
-}
-var init_utils4 = __esm({
-  "../drizzle-orm/dist/pg-core/utils.js"() {
-    "use strict";
-    init_entity();
-    init_table2();
-    init_table();
-    init_view_common();
-    init_checks();
-    init_foreign_keys();
-    init_indexes();
-    init_policies();
-    init_primary_keys();
-    init_unique_constraint();
-    init_view_common2();
-    init_view();
-  }
-});
-
 // ../drizzle-orm/dist/pg-core/utils/index.js
 var init_utils5 = __esm({
   "../drizzle-orm/dist/pg-core/utils/index.js"() {
@@ -32463,7 +32579,7 @@ var init_dialect2 = __esm({
         const withSql = this.buildWithCTE(withList);
         const valuesSql = sql.join(valuesSqlList);
         const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
-        const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
+        const onConflictSql = onConflict?.length ? sql.join(onConflict) : void 0;
         return sql`${withSql}insert into ${table5} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
       }
       sqlToQuery(sql2, invokeSource) {
@@ -33570,12 +33686,14 @@ var init_insert2 = __esm({
        * ```
        */
       onConflictDoNothing(config = {}) {
+        if (!this.config.onConflict)
+          this.config.onConflict = [];
         if (config.target === void 0) {
-          this.config.onConflict = sql`do nothing`;
+          this.config.onConflict.push(sql` on conflict do nothing`);
         } else {
           const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
           const whereSql = config.where ? sql` where ${config.where}` : sql``;
-          this.config.onConflict = sql`${targetSql} do nothing${whereSql}`;
+          this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
         }
         return this;
       }
@@ -33614,12 +33732,16 @@ var init_insert2 = __esm({
             'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
           );
         }
+        if (!this.config.onConflict)
+          this.config.onConflict = [];
         const whereSql = config.where ? sql` where ${config.where}` : void 0;
         const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
         const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
         const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
         const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
-        this.config.onConflict = sql`${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
+        this.config.onConflict.push(
+          sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`
+        );
         return this;
       }
       /** @internal */