drizzle-orm 0.44.2 → 0.44.3-f0d7da2

package/mssql-core/db.d.cts

@@ -0,0 +1,228 @@
+import { entityKind } from "../entity.cjs";
+import type { TypedQueryBuilder } from "../query-builders/query-builder.cjs";
+import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from "../relations.cjs";
+import type { ColumnsSelection, SQLWrapper } from "../sql/sql.cjs";
+import { WithSubquery } from "../subquery.cjs";
+import type { DrizzleTypeError } from "../utils.cjs";
+import type { MsSqlDialect } from "./dialect.cjs";
+import { MsSqlDeleteBase, MsSqlInsertBuilder, MsSqlSelectBuilder, MsSqlUpdateBuilder, QueryBuilder } from "./query-builders/index.cjs";
+import { RelationalQueryBuilder } from "./query-builders/query.cjs";
+import type { SelectedFields } from "./query-builders/select.types.cjs";
+import type { MsSqlSession, MsSqlTransaction, MsSqlTransactionConfig, PreparedQueryHKTBase, QueryResultHKT, QueryResultKind } from "./session.cjs";
+import type { WithSubqueryWithSelection } from "./subquery.cjs";
+import type { MsSqlTable } from "./table.cjs";
+export declare class MsSqlDatabase<TQueryResult extends QueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = {}, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly schema: TSchema | undefined;
+        readonly tableNamesMap: Record<string, string>;
+    };
+    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'> : {
+        [K in keyof TSchema]: RelationalQueryBuilder<TPreparedQueryHKT, TSchema, TSchema[K]>;
+    };
+    constructor(
+    /** @internal */
+    dialect: MsSqlDialect, 
+    /** @internal */
+    session: MsSqlSession<any, any, any, any>, schema: RelationalSchemaConfig<TSchema> | undefined);
+    /**
+     * 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);
+     * ```
+     */
+    $with<TAlias extends string>(alias: TAlias): {
+        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): WithSubqueryWithSelection<TSelection, TAlias>;
+    };
+    /**
+     * 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: WithSubquery[]): {
+        select: {
+            (): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+            <TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+        };
+        selectDistinct: {
+            (): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+            <TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+        };
+    };
+    /**
+     * Creates a select query.
+     *
+     * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+     *
+     * Use `.from()` method to specify which table to select from.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/select}
+     *
+     * @param fields The selection object.
+     *
+     * @example
+     *
+     * ```ts
+     * // Select all columns and all rows from the 'cars' table
+     * const allCars: Car[] = await db.select().from(cars);
+     *
+     * // Select specific columns and all rows from the 'cars' table
+     * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+     *   id: cars.id,
+     *   brand: cars.brand
+     * })
+     *   .from(cars);
+     * ```
+     *
+     * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+     *
+     * ```ts
+     * // Select specific columns along with expression and all rows from the 'cars' table
+     * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+     *   id: cars.id,
+     *   lowerBrand: sql<string>`lower(${cars.brand})`,
+     * })
+     *   .from(cars);
+     * ```
+     */
+    select(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+    select<TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+    /**
+     * Adds `distinct` expression to the select query.
+     *
+     * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+     *
+     * Use `.from()` method to specify which table to select from.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+     *
+     * @param fields The selection object.
+     *
+     * @example
+     * ```ts
+     * // Select all unique rows from the 'cars' table
+     * await db.selectDistinct()
+     *   .from(cars)
+     *   .orderBy(cars.id, cars.brand, cars.color);
+     *
+     * // Select all unique brands from the 'cars' table
+     * await db.selectDistinct({ brand: cars.brand })
+     *   .from(cars)
+     *   .orderBy(cars.brand);
+     * ```
+     */
+    selectDistinct(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+    /**
+     * 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<TTable extends MsSqlTable>(table: TTable): MsSqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT>;
+    /**
+     * 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<TTable extends MsSqlTable>(table: TTable): MsSqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT>;
+    /**
+     * 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<TTable extends MsSqlTable>(table: TTable): MsSqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT>;
+    execute<T extends {
+        [column: string]: any;
+    } | {
+        [column: string]: any;
+    }[]>(query: SQLWrapper): Promise<QueryResultKind<TQueryResult, T>>;
+    transaction<T>(transaction: (tx: MsSqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>, config?: MsSqlTransactionConfig) => Promise<T>, config?: MsSqlTransactionConfig): Promise<T>;
+}
+export type MySQLWithReplicas<Q> = Q & {
+    $primary: Q;
+};
+export declare const withReplicas: <HKT extends QueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, Q extends MsSqlDatabase<HKT, TPreparedQueryHKT, TFullSchema, TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema>>(primary: Q, replicas: [Q, ...Q[]], getReplica?: (replicas: Q[]) => Q) => MySQLWithReplicas<Q>;

package/mssql-core/db.d.ts

@@ -0,0 +1,228 @@
+import { entityKind } from "../entity.js";
+import type { TypedQueryBuilder } from "../query-builders/query-builder.js";
+import type { ExtractTablesWithRelations, RelationalSchemaConfig, TablesRelationalConfig } from "../relations.js";
+import type { ColumnsSelection, SQLWrapper } from "../sql/sql.js";
+import { WithSubquery } from "../subquery.js";
+import type { DrizzleTypeError } from "../utils.js";
+import type { MsSqlDialect } from "./dialect.js";
+import { MsSqlDeleteBase, MsSqlInsertBuilder, MsSqlSelectBuilder, MsSqlUpdateBuilder, QueryBuilder } from "./query-builders/index.js";
+import { RelationalQueryBuilder } from "./query-builders/query.js";
+import type { SelectedFields } from "./query-builders/select.types.js";
+import type { MsSqlSession, MsSqlTransaction, MsSqlTransactionConfig, PreparedQueryHKTBase, QueryResultHKT, QueryResultKind } from "./session.js";
+import type { WithSubqueryWithSelection } from "./subquery.js";
+import type { MsSqlTable } from "./table.js";
+export declare class MsSqlDatabase<TQueryResult extends QueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown> = {}, TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>> {
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly schema: TSchema | undefined;
+        readonly tableNamesMap: Record<string, string>;
+    };
+    query: TFullSchema extends Record<string, never> ? DrizzleTypeError<'Seems like the schema generic is missing - did you forget to add it to your DB type?'> : {
+        [K in keyof TSchema]: RelationalQueryBuilder<TPreparedQueryHKT, TSchema, TSchema[K]>;
+    };
+    constructor(
+    /** @internal */
+    dialect: MsSqlDialect, 
+    /** @internal */
+    session: MsSqlSession<any, any, any, any>, schema: RelationalSchemaConfig<TSchema> | undefined);
+    /**
+     * 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);
+     * ```
+     */
+    $with<TAlias extends string>(alias: TAlias): {
+        as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): WithSubqueryWithSelection<TSelection, TAlias>;
+    };
+    /**
+     * 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: WithSubquery[]): {
+        select: {
+            (): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+            <TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+        };
+        selectDistinct: {
+            (): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+            <TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+        };
+    };
+    /**
+     * Creates a select query.
+     *
+     * Calling this method with no arguments will select all columns from the table. Pass a selection object to specify the columns you want to select.
+     *
+     * Use `.from()` method to specify which table to select from.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/select}
+     *
+     * @param fields The selection object.
+     *
+     * @example
+     *
+     * ```ts
+     * // Select all columns and all rows from the 'cars' table
+     * const allCars: Car[] = await db.select().from(cars);
+     *
+     * // Select specific columns and all rows from the 'cars' table
+     * const carsIdsAndBrands: { id: number; brand: string }[] = await db.select({
+     *   id: cars.id,
+     *   brand: cars.brand
+     * })
+     *   .from(cars);
+     * ```
+     *
+     * Like in SQL, you can use arbitrary expressions as selection fields, not just table columns:
+     *
+     * ```ts
+     * // Select specific columns along with expression and all rows from the 'cars' table
+     * const carsIdsAndLowerNames: { id: number; lowerBrand: string }[] = await db.select({
+     *   id: cars.id,
+     *   lowerBrand: sql<string>`lower(${cars.brand})`,
+     * })
+     *   .from(cars);
+     * ```
+     */
+    select(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+    select<TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+    /**
+     * Adds `distinct` expression to the select query.
+     *
+     * Calling this method will return only unique values. When multiple columns are selected, it returns rows with unique combinations of values in these columns.
+     *
+     * Use `.from()` method to specify which table to select from.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/select#distinct}
+     *
+     * @param fields The selection object.
+     *
+     * @example
+     * ```ts
+     * // Select all unique rows from the 'cars' table
+     * await db.selectDistinct()
+     *   .from(cars)
+     *   .orderBy(cars.id, cars.brand, cars.color);
+     *
+     * // Select all unique brands from the 'cars' table
+     * await db.selectDistinct({ brand: cars.brand })
+     *   .from(cars)
+     *   .orderBy(cars.brand);
+     * ```
+     */
+    selectDistinct(): MsSqlSelectBuilder<undefined, TPreparedQueryHKT>;
+    selectDistinct<TSelection extends SelectedFields>(fields: TSelection): MsSqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+    /**
+     * 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<TTable extends MsSqlTable>(table: TTable): MsSqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT>;
+    /**
+     * 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<TTable extends MsSqlTable>(table: TTable): MsSqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT>;
+    /**
+     * 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<TTable extends MsSqlTable>(table: TTable): MsSqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT>;
+    execute<T extends {
+        [column: string]: any;
+    } | {
+        [column: string]: any;
+    }[]>(query: SQLWrapper): Promise<QueryResultKind<TQueryResult, T>>;
+    transaction<T>(transaction: (tx: MsSqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>, config?: MsSqlTransactionConfig) => Promise<T>, config?: MsSqlTransactionConfig): Promise<T>;
+}
+export type MySQLWithReplicas<Q> = Q & {
+    $primary: Q;
+};
+export declare const withReplicas: <HKT extends QueryResultHKT, TPreparedQueryHKT extends PreparedQueryHKTBase, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, Q extends MsSqlDatabase<HKT, TPreparedQueryHKT, TFullSchema, TSchema extends Record<string, unknown> ? ExtractTablesWithRelations<TFullSchema> : TSchema>>(primary: Q, replicas: [Q, ...Q[]], getReplica?: (replicas: Q[]) => Q) => MySQLWithReplicas<Q>;

package/mssql-core/db.js

@@ -0,0 +1,235 @@
+import { entityKind } from "../entity.js";
+import { SelectionProxyHandler } from "../selection-proxy.js";
+import { WithSubquery } from "../subquery.js";
+import {
+  MsSqlDeleteBase,
+  MsSqlInsertBuilder,
+  MsSqlSelectBuilder,
+  MsSqlUpdateBuilder,
+  QueryBuilder
+} from "./query-builders/index.js";
+import { RelationalQueryBuilder } from "./query-builders/query.js";
+class MsSqlDatabase {
+  constructor(dialect, session, schema) {
+    this.dialect = dialect;
+    this.session = session;
+    this._ = schema ? { schema: schema.schema, tableNamesMap: schema.tableNamesMap } : { schema: void 0, tableNamesMap: {} };
+    this.query = {};
+    if (this._.schema) {
+      for (const [tableName, columns] of Object.entries(this._.schema)) {
+        this.query[tableName] = new RelationalQueryBuilder(
+          schema.fullSchema,
+          this._.schema,
+          this._.tableNamesMap,
+          schema.fullSchema[tableName],
+          columns,
+          dialect,
+          session
+        );
+      }
+    }
+  }
+  static [entityKind] = "MsSqlDatabase";
+  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);
+   * ```
+   */
+  $with(alias) {
+    const self = this;
+    return {
+      as(qb) {
+        if (typeof qb === "function") {
+          qb = qb(new QueryBuilder(self.dialect));
+        }
+        return new Proxy(
+          new WithSubquery(qb.getSQL(), qb.getSelectedFields(), alias, true),
+          new SelectionProxyHandler({ alias, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
+        );
+      }
+    };
+  }
+  /**
+   * 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 self = this;
+    function select(fields) {
+      return new MsSqlSelectBuilder({
+        fields: fields ?? void 0,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries
+      });
+    }
+    function selectDistinct(fields) {
+      return new MsSqlSelectBuilder({
+        fields: fields ?? void 0,
+        session: self.session,
+        dialect: self.dialect,
+        withList: queries,
+        distinct: true
+      });
+    }
+    return { select, selectDistinct };
+  }
+  select(fields) {
+    return new MsSqlSelectBuilder({ fields: fields ?? void 0, session: this.session, dialect: this.dialect });
+  }
+  selectDistinct(fields) {
+    return new MsSqlSelectBuilder({
+      fields: fields ?? void 0,
+      session: this.session,
+      dialect: this.dialect,
+      distinct: true
+    });
+  }
+  /**
+   * 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(table) {
+    return new MsSqlUpdateBuilder(table, this.session, this.dialect);
+  }
+  /**
+   * 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(table) {
+    return new MsSqlInsertBuilder(table, this.session, this.dialect);
+  }
+  /**
+   * 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(table) {
+    return new MsSqlDeleteBase(table, this.session, this.dialect);
+  }
+  execute(query) {
+    return this.session.execute(query.getSQL());
+  }
+  transaction(transaction, config) {
+    return this.session.transaction(transaction, config);
+  }
+}
+const withReplicas = (primary, replicas, getReplica = () => replicas[Math.floor(Math.random() * replicas.length)]) => {
+  const select = (...args) => getReplica(replicas).select(...args);
+  const selectDistinct = (...args) => getReplica(replicas).selectDistinct(...args);
+  const $with = (...args) => getReplica(replicas).with(...args);
+  const update = (...args) => primary.update(...args);
+  const insert = (...args) => primary.insert(...args);
+  const $delete = (...args) => primary.delete(...args);
+  const execute = (...args) => primary.execute(...args);
+  const transaction = (...args) => primary.transaction(...args);
+  return {
+    ...primary,
+    update,
+    insert,
+    delete: $delete,
+    execute,
+    transaction,
+    $primary: primary,
+    select,
+    selectDistinct,
+    with: $with,
+    get query() {
+      return getReplica(replicas).query;
+    }
+  };
+};
+export {
+  MsSqlDatabase,
+  withReplicas
+};
+//# sourceMappingURL=db.js.map