@erfanium/drizzle-orm 1.0.0 → 1.0.1

package/cockroach-core/query-builders/update.d.ts

@@ -1,163 +1,169 @@
-import { CockroachColumn } from "../columns/common.js";
-import { CockroachViewBase } from "../view-base.js";
-import { CockroachSelectJoinConfig, SelectedFields, SelectedFieldsOrdered, TableLikeHasEmptySelection } from "./select.types.js";
-import { entityKind } from "../../entity.js";
-import { InferInsertModel, Table } from "../../table.js";
-import { Assume, DrizzleTypeError, Equal, Simplify, UpdateSet } from "../../utils.js";
-import { GetColumnData } from "../../column.js";
-import { ColumnsSelection, Placeholder, Query, SQL, SQLWrapper } from "../../sql/sql.js";
-import { Subquery } from "../../subquery.js";
-import { TypedQueryBuilder } from "../../query-builders/query-builder.js";
-import { QueryPromise } from "../../query-promise.js";
-import { CockroachDialect } from "../dialect.js";
-import { CockroachTable } from "../table.js";
-import { CockroachPreparedQuery, CockroachQueryResultHKT, CockroachQueryResultKind, CockroachSession, PreparedQueryConfig } from "../session.js";
-import { AppendToNullabilityMap, AppendToResult, GetSelectTableName, GetSelectTableSelection, JoinNullability, JoinType, SelectMode, SelectResult } from "../../query-builders/select.types.js";
-import { RunnableQuery } from "../../runnable-query.js";
-
-//#region src/cockroach-core/query-builders/update.d.ts
-interface CockroachUpdateConfig {
-  where?: SQL | undefined;
-  set: UpdateSet;
-  table: CockroachTable;
-  from?: CockroachTable | Subquery | CockroachViewBase | SQL;
-  joins: CockroachSelectJoinConfig[];
-  returningFields?: SelectedFields;
-  returning?: SelectedFieldsOrdered;
-  withList?: Subquery[];
+import type { CockroachDialect } from '../dialect.js';
+import type { CockroachPreparedQuery, CockroachQueryResultHKT, CockroachQueryResultKind, CockroachSession, PreparedQueryConfig } from '../session.js';
+import { CockroachTable } from '../table.js';
+import type { GetColumnData } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { AppendToNullabilityMap, AppendToResult, GetSelectTableName, GetSelectTableSelection, JoinNullability, JoinType, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import { QueryPromise } from '../../query-promise.js';
+import type { RunnableQuery } from '../../runnable-query.js';
+import { type ColumnsSelection, type Placeholder, type Query, SQL, type SQLWrapper } from '../../sql/sql.js';
+import { Subquery } from '../../subquery.js';
+import { type InferInsertModel, Table } from '../../table.js';
+import { type Assume, type DrizzleTypeError, type Equal, type Simplify, type UpdateSet } from '../../utils.js';
+import type { CockroachColumn } from '../columns/common.js';
+import type { CockroachViewBase } from '../view-base.js';
+import type { CockroachSelectJoinConfig, SelectedFields, SelectedFieldsOrdered, TableLikeHasEmptySelection } from './select.types.js';
+export interface CockroachUpdateConfig {
+    where?: SQL | undefined;
+    set: UpdateSet;
+    table: CockroachTable;
+    from?: CockroachTable | Subquery | CockroachViewBase | SQL;
+    joins: CockroachSelectJoinConfig[];
+    returningFields?: SelectedFields;
+    returning?: SelectedFieldsOrdered;
+    withList?: Subquery[];
 }
-type CockroachUpdateSetSource<TTable extends CockroachTable> = { [Key in keyof InferInsertModel<TTable>]?: GetColumnData<TTable['_']['columns'][Key]> | SQL | CockroachColumn | Placeholder | undefined } & {};
-declare class CockroachUpdateBuilder<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT> {
-  private table;
-  private session;
-  private dialect;
-  private withList?;
-  static readonly [entityKind]: string;
-  readonly _: {
-    readonly table: TTable;
-  };
-  constructor(table: TTable, session: CockroachSession, dialect: CockroachDialect, withList?: Subquery[] | undefined);
-  set(values: CockroachUpdateSetSource<TTable>): CockroachUpdateWithout<CockroachUpdateBase<TTable, TQueryResult>, false, 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>;
+export type CockroachUpdateSetSource<TTable extends CockroachTable> = {
+    [Key in keyof InferInsertModel<TTable>]?: GetColumnData<TTable['_']['columns'][Key]> | SQL | CockroachColumn | Placeholder | undefined;
+} & {};
+export declare class CockroachUpdateBuilder<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT> {
+    private table;
+    private session;
+    private dialect;
+    private withList?;
+    static readonly [entityKind]: string;
+    readonly _: {
+        readonly table: TTable;
+    };
+    constructor(table: TTable, session: CockroachSession, dialect: CockroachDialect, withList?: Subquery[] | undefined);
+    set(values: CockroachUpdateSetSource<TTable>): CockroachUpdateWithout<CockroachUpdateBase<TTable, TQueryResult>, false, 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>;
 }
-type CockroachUpdateWithout<T extends AnyCockroachUpdate, TDynamic extends boolean, K extends keyof T & string> = TDynamic extends true ? T : Omit<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], T['_']['selectedFields'], T['_']['returning'], T['_']['nullabilityMap'], T['_']['joins'], TDynamic, T['_']['excludedMethods'] | K>, T['_']['excludedMethods'] | K>;
-type CockroachUpdateWithJoins<T extends AnyCockroachUpdate, TDynamic extends boolean, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL> = TDynamic extends true ? T : Omit<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], TFrom, T['_']['selectedFields'], T['_']['returning'], AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TFrom>, 'inner'>, [...T['_']['joins'], {
-  name: GetSelectTableName<TFrom>;
-  joinType: 'inner';
-  table: TFrom;
-}], TDynamic, Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>>, Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>>;
-type CockroachUpdateJoinFn<T extends AnyCockroachUpdate, TDynamic extends boolean, TJoinType extends JoinType> = <TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL>(table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"> : TJoinedTable, on: ((updateTable: T['_']['table']['_']['columns'], from: T['_']['from'] extends CockroachTable ? T['_']['from']['_']['columns'] : T['_']['from'] extends Subquery | CockroachViewBase ? T['_']['from']['_']['selectedFields'] : never) => SQL | undefined) | SQL | undefined) => CockroachUpdateJoin<T, TDynamic, TJoinType, TJoinedTable>;
-type CockroachUpdateJoin<T extends AnyCockroachUpdate, TDynamic extends boolean, TJoinType extends JoinType, TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL> = TDynamic extends true ? T : CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], T['_']['selectedFields'], T['_']['returning'], AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TJoinedTable>, TJoinType>, [...T['_']['joins'], {
-  name: GetSelectTableName<TJoinedTable>;
-  joinType: TJoinType;
-  table: TJoinedTable;
-}], TDynamic, T['_']['excludedMethods']>;
+export type CockroachUpdateWithout<T extends AnyCockroachUpdate, TDynamic extends boolean, K extends keyof T & string> = TDynamic extends true ? T : Omit<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], T['_']['selectedFields'], T['_']['returning'], T['_']['nullabilityMap'], T['_']['joins'], TDynamic, T['_']['excludedMethods'] | K>, T['_']['excludedMethods'] | K>;
+export type CockroachUpdateWithJoins<T extends AnyCockroachUpdate, TDynamic extends boolean, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL> = TDynamic extends true ? T : Omit<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], TFrom, T['_']['selectedFields'], T['_']['returning'], AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TFrom>, 'inner'>, [
+    ...T['_']['joins'],
+    {
+        name: GetSelectTableName<TFrom>;
+        joinType: 'inner';
+        table: TFrom;
+    }
+], TDynamic, Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>>, Exclude<T['_']['excludedMethods'] | 'from', 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>>;
+export type CockroachUpdateJoinFn<T extends AnyCockroachUpdate, TDynamic extends boolean, TJoinType extends JoinType> = <TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL>(table: TableLikeHasEmptySelection<TJoinedTable> extends true ? DrizzleTypeError<"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"> : TJoinedTable, on: ((updateTable: T['_']['table']['_']['columns'], from: T['_']['from'] extends CockroachTable ? T['_']['from']['_']['columns'] : T['_']['from'] extends Subquery | CockroachViewBase ? T['_']['from']['_']['selectedFields'] : never) => SQL | undefined) | SQL | undefined) => CockroachUpdateJoin<T, TDynamic, TJoinType, TJoinedTable>;
+export type CockroachUpdateJoin<T extends AnyCockroachUpdate, TDynamic extends boolean, TJoinType extends JoinType, TJoinedTable extends CockroachTable | Subquery | CockroachViewBase | SQL> = TDynamic extends true ? T : CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], T['_']['selectedFields'], T['_']['returning'], AppendToNullabilityMap<T['_']['nullabilityMap'], GetSelectTableName<TJoinedTable>, TJoinType>, [
+    ...T['_']['joins'],
+    {
+        name: GetSelectTableName<TJoinedTable>;
+        joinType: TJoinType;
+        table: TJoinedTable;
+    }
+], TDynamic, T['_']['excludedMethods']>;
 type Join = {
-  name: string | undefined;
-  joinType: JoinType;
-  table: CockroachTable | Subquery | CockroachViewBase | SQL;
+    name: string | undefined;
+    joinType: JoinType;
+    table: CockroachTable | Subquery | CockroachViewBase | SQL;
 };
 type AccumulateToResult<T extends AnyCockroachUpdate, TSelectMode extends SelectMode, TJoins extends Join[], TSelectedFields extends ColumnsSelection> = TJoins extends [infer TJoin extends Join, ...infer TRest extends Join[]] ? AccumulateToResult<T, TSelectMode extends 'partial' ? TSelectMode : 'multiple', TRest, AppendToResult<T['_']['table']['_']['name'], TSelectedFields, TJoin['name'], TJoin['table'] extends Table ? TJoin['table']['_']['columns'] : TJoin['table'] extends Subquery ? Assume<TJoin['table']['_']['selectedFields'], SelectedFields> : never, TSelectMode extends 'partial' ? TSelectMode : 'multiple'>> : TSelectedFields;
-type CockroachUpdateReturningAll<T extends AnyCockroachUpdate, TDynamic extends boolean> = CockroachUpdateWithout<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], Equal<T['_']['joins'], []> extends true ? T['_']['table']['_']['columns'] : Simplify<Record<T['_']['table']['_']['name'], T['_']['table']['_']['columns']> & { [K in keyof T['_']['joins'] as T['_']['joins'][K]['table']['_']['name']]: T['_']['joins'][K]['table']['_']['columns'] }>, SelectResult<AccumulateToResult<T, 'single', T['_']['joins'], GetSelectTableSelection<T['_']['table']>>, 'partial', T['_']['nullabilityMap']>, T['_']['nullabilityMap'], T['_']['joins'], TDynamic, T['_']['excludedMethods']>, TDynamic, 'returning'>;
-type CockroachUpdateReturning<T extends AnyCockroachUpdate, TDynamic extends boolean, TSelectedFields extends SelectedFields> = CockroachUpdateWithout<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], TSelectedFields, SelectResult<AccumulateToResult<T, 'partial', T['_']['joins'], TSelectedFields>, 'partial', T['_']['nullabilityMap']>, T['_']['nullabilityMap'], T['_']['joins'], TDynamic, T['_']['excludedMethods']>, TDynamic, 'returning'>;
-type CockroachUpdatePrepare<T extends AnyCockroachUpdate> = CockroachPreparedQuery<PreparedQueryConfig & {
-  execute: T['_']['returning'] extends undefined ? CockroachQueryResultKind<T['_']['queryResult'], never> : T['_']['returning'][];
+export type CockroachUpdateReturningAll<T extends AnyCockroachUpdate, TDynamic extends boolean> = CockroachUpdateWithout<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], Equal<T['_']['joins'], []> extends true ? T['_']['table']['_']['columns'] : Simplify<Record<T['_']['table']['_']['name'], T['_']['table']['_']['columns']> & {
+    [K in keyof T['_']['joins'] as T['_']['joins'][K]['table']['_']['name']]: T['_']['joins'][K]['table']['_']['columns'];
+}>, SelectResult<AccumulateToResult<T, 'single', T['_']['joins'], GetSelectTableSelection<T['_']['table']>>, 'partial', T['_']['nullabilityMap']>, T['_']['nullabilityMap'], T['_']['joins'], TDynamic, T['_']['excludedMethods']>, TDynamic, 'returning'>;
+export type CockroachUpdateReturning<T extends AnyCockroachUpdate, TDynamic extends boolean, TSelectedFields extends SelectedFields> = CockroachUpdateWithout<CockroachUpdateBase<T['_']['table'], T['_']['queryResult'], T['_']['from'], TSelectedFields, SelectResult<AccumulateToResult<T, 'partial', T['_']['joins'], TSelectedFields>, 'partial', T['_']['nullabilityMap']>, T['_']['nullabilityMap'], T['_']['joins'], TDynamic, T['_']['excludedMethods']>, TDynamic, 'returning'>;
+export type CockroachUpdatePrepare<T extends AnyCockroachUpdate> = CockroachPreparedQuery<PreparedQueryConfig & {
+    execute: T['_']['returning'] extends undefined ? CockroachQueryResultKind<T['_']['queryResult'], never> : T['_']['returning'][];
 }>;
-type CockroachUpdateDynamic<T extends AnyCockroachUpdate> = CockroachUpdate<T['_']['table'], T['_']['queryResult'], T['_']['from'], T['_']['returning'], T['_']['nullabilityMap']>;
-type CockroachUpdate<TTable extends CockroachTable = CockroachTable, TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined, TSelectedFields extends ColumnsSelection | undefined = undefined, TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined, TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>, TJoins extends Join[] = []> = CockroachUpdateBase<TTable, TQueryResult, TFrom, TSelectedFields, TReturning, TNullabilityMap, TJoins, true, never>;
-type AnyCockroachUpdate = CockroachUpdateBase<any, any, any, any, any, any, any, any, any>;
-interface CockroachUpdateBase<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined, TSelectedFields extends ColumnsSelection | undefined = undefined, TReturning extends Record<string, unknown> | undefined = undefined, TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>, TJoins extends Join[] = [], TDynamic extends boolean = false, TExcludedMethods extends string = never> extends TypedQueryBuilder<TSelectedFields, TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>, QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>, RunnableQuery<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[], 'cockroach'>, SQLWrapper {
-  readonly _: {
-    readonly dialect: 'cockroach';
-    readonly table: TTable;
-    readonly joins: TJoins;
-    readonly nullabilityMap: TNullabilityMap;
-    readonly queryResult: TQueryResult;
-    readonly from: TFrom;
-    readonly selectedFields: TSelectedFields;
-    readonly returning: TReturning;
-    readonly dynamic: TDynamic;
-    readonly excludedMethods: TExcludedMethods;
-    readonly result: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
-  };
+export type CockroachUpdateDynamic<T extends AnyCockroachUpdate> = CockroachUpdate<T['_']['table'], T['_']['queryResult'], T['_']['from'], T['_']['returning'], T['_']['nullabilityMap']>;
+export type CockroachUpdate<TTable extends CockroachTable = CockroachTable, TQueryResult extends CockroachQueryResultHKT = CockroachQueryResultHKT, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined, TSelectedFields extends ColumnsSelection | undefined = undefined, TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined, TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>, TJoins extends Join[] = []> = CockroachUpdateBase<TTable, TQueryResult, TFrom, TSelectedFields, TReturning, TNullabilityMap, TJoins, true, never>;
+export type AnyCockroachUpdate = CockroachUpdateBase<any, any, any, any, any, any, any, any, any>;
+export interface CockroachUpdateBase<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined, TSelectedFields extends ColumnsSelection | undefined = undefined, TReturning extends Record<string, unknown> | undefined = undefined, TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>, TJoins extends Join[] = [], TDynamic extends boolean = false, TExcludedMethods extends string = never> extends TypedQueryBuilder<TSelectedFields, TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>, QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]>, RunnableQuery<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[], 'cockroach'>, SQLWrapper {
+    readonly _: {
+        readonly dialect: 'cockroach';
+        readonly table: TTable;
+        readonly joins: TJoins;
+        readonly nullabilityMap: TNullabilityMap;
+        readonly queryResult: TQueryResult;
+        readonly from: TFrom;
+        readonly selectedFields: TSelectedFields;
+        readonly returning: TReturning;
+        readonly dynamic: TDynamic;
+        readonly excludedMethods: TExcludedMethods;
+        readonly result: TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[];
+    };
 }
-declare class CockroachUpdateBase<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined, TSelectedFields extends ColumnsSelection | undefined = undefined, TReturning extends Record<string, unknown> | undefined = undefined, TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>, TJoins extends Join[] = [], TDynamic extends boolean = false, TExcludedMethods extends string = never> extends QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]> implements RunnableQuery<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[], 'cockroach'>, SQLWrapper {
-  private session;
-  private dialect;
-  static readonly [entityKind]: string;
-  private config;
-  private tableName;
-  private joinsNotNullableMap;
-  constructor(table: TTable, set: UpdateSet, session: CockroachSession, dialect: CockroachDialect, withList?: Subquery[]);
-  from<TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL>(source: TableLikeHasEmptySelection<TFrom> extends true ? DrizzleTypeError<"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"> : TFrom): CockroachUpdateWithJoins<this, TDynamic, TFrom>;
-  private getTableLikeFields;
-  private createJoin;
-  leftJoin: CockroachUpdateJoinFn<this, TDynamic, "left">;
-  rightJoin: CockroachUpdateJoinFn<this, TDynamic, "right">;
-  innerJoin: CockroachUpdateJoinFn<this, TDynamic, "inner">;
-  fullJoin: CockroachUpdateJoinFn<this, TDynamic, "full">;
-  /**
-   * Adds a 'where' clause to the query.
-   *
-   * Calling this method will update only those rows that fulfill a specified condition.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/update}
-   *
-   * @param where the 'where' clause.
-   *
-   * @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'`)
-   * ```
-   *
-   * 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')));
-   * ```
-   */
-  where(where: SQL | undefined): CockroachUpdateWithout<this, TDynamic, 'where'>;
-  /**
-   * Adds a `returning` clause to the query.
-   *
-   * Calling this method will return the specified fields of the updated rows. If no fields are specified, all fields will be returned.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/update#update-with-returning}
-   *
-   * @example
-   * ```ts
-   * // Update all cars with the green color and return all fields
-   * const updatedCars: Car[] = await db.update(cars)
-   *   .set({ color: 'red' })
-   *   .where(eq(cars.color, 'green'))
-   *   .returning();
-   *
-   * // Update all cars with the green color and return only their id and brand fields
-   * const updatedCarsIdsAndBrands: { id: number, brand: string }[] = await db.update(cars)
-   *   .set({ color: 'red' })
-   *   .where(eq(cars.color, 'green'))
-   *   .returning({ id: cars.id, brand: cars.brand });
-   * ```
-   */
-  returning(): CockroachUpdateReturningAll<this, TDynamic>;
-  returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): CockroachUpdateReturning<this, TDynamic, TSelectedFields>;
-  toSQL(): Query;
-  prepare(name?: string): CockroachUpdatePrepare<this>;
-  execute: ReturnType<this['prepare']>['execute'];
-  $dynamic(): CockroachUpdateDynamic<this>;
+export declare class CockroachUpdateBase<TTable extends CockroachTable, TQueryResult extends CockroachQueryResultHKT, TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL | undefined = undefined, TSelectedFields extends ColumnsSelection | undefined = undefined, TReturning extends Record<string, unknown> | undefined = undefined, TNullabilityMap extends Record<string, JoinNullability> = Record<TTable['_']['name'], 'not-null'>, TJoins extends Join[] = [], TDynamic extends boolean = false, TExcludedMethods extends string = never> extends QueryPromise<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[]> implements RunnableQuery<TReturning extends undefined ? CockroachQueryResultKind<TQueryResult, never> : TReturning[], 'cockroach'>, SQLWrapper {
+    private session;
+    private dialect;
+    static readonly [entityKind]: string;
+    private config;
+    private tableName;
+    private joinsNotNullableMap;
+    constructor(table: TTable, set: UpdateSet, session: CockroachSession, dialect: CockroachDialect, withList?: Subquery[]);
+    from<TFrom extends CockroachTable | Subquery | CockroachViewBase | SQL>(source: TableLikeHasEmptySelection<TFrom> extends true ? DrizzleTypeError<"Cannot reference a data-modifying statement subquery if it doesn't contain a `returning` clause"> : TFrom): CockroachUpdateWithJoins<this, TDynamic, TFrom>;
+    private getTableLikeFields;
+    private createJoin;
+    leftJoin: CockroachUpdateJoinFn<this, TDynamic, "left">;
+    rightJoin: CockroachUpdateJoinFn<this, TDynamic, "right">;
+    innerJoin: CockroachUpdateJoinFn<this, TDynamic, "inner">;
+    fullJoin: CockroachUpdateJoinFn<this, TDynamic, "full">;
+    /**
+     * Adds a 'where' clause to the query.
+     *
+     * Calling this method will update only those rows that fulfill a specified condition.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/update}
+     *
+     * @param where the 'where' clause.
+     *
+     * @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'`)
+     * ```
+     *
+     * 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')));
+     * ```
+     */
+    where(where: SQL | undefined): CockroachUpdateWithout<this, TDynamic, 'where'>;
+    /**
+     * Adds a `returning` clause to the query.
+     *
+     * Calling this method will return the specified fields of the updated rows. If no fields are specified, all fields will be returned.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/update#update-with-returning}
+     *
+     * @example
+     * ```ts
+     * // Update all cars with the green color and return all fields
+     * const updatedCars: Car[] = await db.update(cars)
+     *   .set({ color: 'red' })
+     *   .where(eq(cars.color, 'green'))
+     *   .returning();
+     *
+     * // Update all cars with the green color and return only their id and brand fields
+     * const updatedCarsIdsAndBrands: { id: number, brand: string }[] = await db.update(cars)
+     *   .set({ color: 'red' })
+     *   .where(eq(cars.color, 'green'))
+     *   .returning({ id: cars.id, brand: cars.brand });
+     * ```
+     */
+    returning(): CockroachUpdateReturningAll<this, TDynamic>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): CockroachUpdateReturning<this, TDynamic, TSelectedFields>;
+    toSQL(): Query;
+    prepare(name?: string): CockroachUpdatePrepare<this>;
+    execute: ReturnType<this['prepare']>['execute'];
+    $dynamic(): CockroachUpdateDynamic<this>;
 }
-//#endregion
-export { AnyCockroachUpdate, CockroachUpdate, CockroachUpdateBase, CockroachUpdateBuilder, CockroachUpdateConfig, CockroachUpdateDynamic, CockroachUpdateJoin, CockroachUpdateJoinFn, CockroachUpdatePrepare, CockroachUpdateReturning, CockroachUpdateReturningAll, CockroachUpdateSetSource, CockroachUpdateWithJoins, CockroachUpdateWithout };
-//# sourceMappingURL=update.d.ts.map
+export {};

package/cockroach-core/query-builders/update.js

@@ -1,9 +1,9 @@
 import { entityKind, is } from "../../entity.js";
+import { Subquery } from "../../subquery.js";
+import { ViewBaseConfig } from "../../view-common.js";
 import { Table, getTableName } from "../../table.js";
 import { getTableLikeName, mapUpdateSet, orderSelectedFields } from "../../utils.js";
 import { SQL } from "../../sql/sql.js";
-import { Subquery } from "../../subquery.js";
-import { ViewBaseConfig } from "../../view-common.js";
 import { preparedStatementName } from "../../query-name-generator.js";
 import { SelectionProxyHandler } from "../../selection-proxy.js";
 import { QueryPromise } from "../../query-promise.js";

package/cockroach-core/roles.d.cts

@@ -1,17 +1,12 @@
-import { entityKind } from "../entity.cjs";
-
-//#region src/cockroach-core/roles.d.ts
-interface CockroachRoleConfig {
-  createDb?: boolean;
-  createRole?: boolean;
+import { entityKind } from '../entity.cjs';
+export interface CockroachRoleConfig {
+    createDb?: boolean;
+    createRole?: boolean;
 }
-declare class CockroachRole implements CockroachRoleConfig {
-  readonly name: string;
-  static readonly [entityKind]: string;
-  constructor(name: string, config?: CockroachRoleConfig);
-  existing(): this;
+export declare class CockroachRole implements CockroachRoleConfig {
+    readonly name: string;
+    static readonly [entityKind]: string;
+    constructor(name: string, config?: CockroachRoleConfig);
+    existing(): this;
 }
-declare function cockroachRole(name: string, config?: CockroachRoleConfig): CockroachRole;
-//#endregion
-export { CockroachRole, CockroachRoleConfig, cockroachRole };
-//# sourceMappingURL=roles.d.cts.map
+export declare function cockroachRole(name: string, config?: CockroachRoleConfig): CockroachRole;

package/cockroach-core/roles.d.ts

@@ -1,17 +1,12 @@
-import { entityKind } from "../entity.js";
-
-//#region src/cockroach-core/roles.d.ts
-interface CockroachRoleConfig {
-  createDb?: boolean;
-  createRole?: boolean;
+import { entityKind } from '../entity.js';
+export interface CockroachRoleConfig {
+    createDb?: boolean;
+    createRole?: boolean;
 }
-declare class CockroachRole implements CockroachRoleConfig {
-  readonly name: string;
-  static readonly [entityKind]: string;
-  constructor(name: string, config?: CockroachRoleConfig);
-  existing(): this;
+export declare class CockroachRole implements CockroachRoleConfig {
+    readonly name: string;
+    static readonly [entityKind]: string;
+    constructor(name: string, config?: CockroachRoleConfig);
+    existing(): this;
 }
-declare function cockroachRole(name: string, config?: CockroachRoleConfig): CockroachRole;
-//#endregion
-export { CockroachRole, CockroachRoleConfig, cockroachRole };
-//# sourceMappingURL=roles.d.ts.map
+export declare function cockroachRole(name: string, config?: CockroachRoleConfig): CockroachRole;

package/cockroach-core/schema.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_cockroach_core_columns_enum = require('./columns/enum.cjs');
-const require_cockroach_core_sequence = require('./sequence.cjs');
 const require_cockroach_core_table = require('./table.cjs');
 const require_cockroach_core_view = require('./view.cjs');
+const require_cockroach_core_columns_enum = require('./columns/enum.cjs');
+const require_cockroach_core_sequence = require('./sequence.cjs');
 let __entity_ts = require("../entity.cjs");
 let __sql_sql_ts = require("../sql/sql.cjs");
 

package/cockroach-core/schema.d.cts

@@ -1,31 +1,26 @@
-import { cockroachSequence } from "./sequence.cjs";
-import { CockroachEnum, CockroachEnumObject } from "./columns/enum.cjs";
-import { cockroachMaterializedView, cockroachView } from "./view.cjs";
-import { CockroachTableFn } from "./table.cjs";
-import { entityKind } from "../entity.cjs";
-import { SQL, SQLWrapper } from "../sql/sql.cjs";
-import { NonArray, Writable } from "../utils.cjs";
-import { Casing } from "../casing.cjs";
-
-//#region src/cockroach-core/schema.d.ts
-declare class CockroachSchema<TName extends string = string> implements SQLWrapper {
-  readonly schemaName: TName;
-  protected casing: Casing | undefined;
-  static readonly [entityKind]: string;
-  isExisting: boolean;
-  constructor(schemaName: TName, casing: Casing | undefined);
-  table: CockroachTableFn<TName>;
-  view: typeof cockroachView;
-  materializedView: typeof cockroachMaterializedView;
-  enum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): CockroachEnum<Writable<T>>;
-  enum<E extends Record<string, string>>(enumName: string, enumObj: NonArray<E>): CockroachEnumObject<E>;
-  sequence: typeof cockroachSequence;
-  getSQL(): SQL;
-  shouldOmitSQLParens(): boolean;
-  existing(): this;
+import type { Casing } from '../casing.cjs';
+import { entityKind } from '../entity.cjs';
+import { SQL, type SQLWrapper } from '../sql/sql.cjs';
+import type { NonArray, Writable } from '../utils.cjs';
+import { type CockroachEnum, type CockroachEnumObject } from './columns/enum.cjs';
+import { type cockroachSequence } from './sequence.cjs';
+import { type CockroachTableFn } from './table.cjs';
+import { type cockroachMaterializedView, type cockroachView } from './view.cjs';
+export declare class CockroachSchema<TName extends string = string> implements SQLWrapper {
+    readonly schemaName: TName;
+    protected casing: Casing | undefined;
+    static readonly [entityKind]: string;
+    isExisting: boolean;
+    constructor(schemaName: TName, casing: Casing | undefined);
+    table: CockroachTableFn<TName>;
+    view: typeof cockroachView;
+    materializedView: typeof cockroachMaterializedView;
+    enum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): CockroachEnum<Writable<T>>;
+    enum<E extends Record<string, string>>(enumName: string, enumObj: NonArray<E>): CockroachEnumObject<E>;
+    sequence: typeof cockroachSequence;
+    getSQL(): SQL;
+    shouldOmitSQLParens(): boolean;
+    existing(): this;
 }
-declare function isCockroachSchema(obj: unknown): obj is CockroachSchema;
-declare function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;
-//#endregion
-export { CockroachSchema, cockroachSchema, isCockroachSchema };
-//# sourceMappingURL=schema.d.cts.map
+export declare function isCockroachSchema(obj: unknown): obj is CockroachSchema;
+export declare function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;

package/cockroach-core/schema.d.ts

@@ -1,31 +1,26 @@
-import { cockroachSequence } from "./sequence.js";
-import { CockroachEnum, CockroachEnumObject } from "./columns/enum.js";
-import { cockroachMaterializedView, cockroachView } from "./view.js";
-import { CockroachTableFn } from "./table.js";
-import { entityKind } from "../entity.js";
-import { Casing } from "../casing.js";
-import { NonArray, Writable } from "../utils.js";
-import { SQL, SQLWrapper } from "../sql/sql.js";
-
-//#region src/cockroach-core/schema.d.ts
-declare class CockroachSchema<TName extends string = string> implements SQLWrapper {
-  readonly schemaName: TName;
-  protected casing: Casing | undefined;
-  static readonly [entityKind]: string;
-  isExisting: boolean;
-  constructor(schemaName: TName, casing: Casing | undefined);
-  table: CockroachTableFn<TName>;
-  view: typeof cockroachView;
-  materializedView: typeof cockroachMaterializedView;
-  enum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): CockroachEnum<Writable<T>>;
-  enum<E extends Record<string, string>>(enumName: string, enumObj: NonArray<E>): CockroachEnumObject<E>;
-  sequence: typeof cockroachSequence;
-  getSQL(): SQL;
-  shouldOmitSQLParens(): boolean;
-  existing(): this;
+import type { Casing } from '../casing.js';
+import { entityKind } from '../entity.js';
+import { SQL, type SQLWrapper } from '../sql/sql.js';
+import type { NonArray, Writable } from '../utils.js';
+import { type CockroachEnum, type CockroachEnumObject } from './columns/enum.js';
+import { type cockroachSequence } from './sequence.js';
+import { type CockroachTableFn } from './table.js';
+import { type cockroachMaterializedView, type cockroachView } from './view.js';
+export declare class CockroachSchema<TName extends string = string> implements SQLWrapper {
+    readonly schemaName: TName;
+    protected casing: Casing | undefined;
+    static readonly [entityKind]: string;
+    isExisting: boolean;
+    constructor(schemaName: TName, casing: Casing | undefined);
+    table: CockroachTableFn<TName>;
+    view: typeof cockroachView;
+    materializedView: typeof cockroachMaterializedView;
+    enum<U extends string, T extends Readonly<[U, ...U[]]>>(enumName: string, values: T | Writable<T>): CockroachEnum<Writable<T>>;
+    enum<E extends Record<string, string>>(enumName: string, enumObj: NonArray<E>): CockroachEnumObject<E>;
+    sequence: typeof cockroachSequence;
+    getSQL(): SQL;
+    shouldOmitSQLParens(): boolean;
+    existing(): this;
 }
-declare function isCockroachSchema(obj: unknown): obj is CockroachSchema;
-declare function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;
-//#endregion
-export { CockroachSchema, cockroachSchema, isCockroachSchema };
-//# sourceMappingURL=schema.d.ts.map
+export declare function isCockroachSchema(obj: unknown): obj is CockroachSchema;
+export declare function cockroachSchema<T extends string>(name: T): CockroachSchema<T>;

package/cockroach-core/schema.js

@@ -1,7 +1,7 @@
-import { cockroachEnumObjectWithSchema, cockroachEnumWithSchema } from "./columns/enum.js";
-import { cockroachSequenceWithSchema } from "./sequence.js";
 import { EnableRLS, cockroachTableWithSchema } from "./table.js";
 import { cockroachMaterializedViewWithSchema, cockroachViewWithSchema } from "./view.js";
+import { cockroachEnumObjectWithSchema, cockroachEnumWithSchema } from "./columns/enum.js";
+import { cockroachSequenceWithSchema } from "./sequence.js";
 import { entityKind, is } from "../entity.js";
 import { SQL, sql } from "../sql/sql.js";
 

package/cockroach-core/sequence.d.cts

@@ -1,22 +1,17 @@
-import { entityKind } from "../entity.cjs";
-
-//#region src/cockroach-core/sequence.d.ts
-type CockroachSequenceOptions = {
-  increment?: number | string;
-  minValue?: number | string;
-  maxValue?: number | string;
-  startWith?: number | string;
-  cache?: number | string;
+import { entityKind } from '../entity.cjs';
+export type CockroachSequenceOptions = {
+    increment?: number | string;
+    minValue?: number | string;
+    maxValue?: number | string;
+    startWith?: number | string;
+    cache?: number | string;
 };
-declare class CockroachSequence {
-  readonly seqName: string;
-  readonly seqOptions: CockroachSequenceOptions | undefined;
-  readonly schema: string | undefined;
-  static readonly [entityKind]: string;
-  constructor(seqName: string, seqOptions: CockroachSequenceOptions | undefined, schema: string | undefined);
+export declare class CockroachSequence {
+    readonly seqName: string;
+    readonly seqOptions: CockroachSequenceOptions | undefined;
+    readonly schema: string | undefined;
+    static readonly [entityKind]: string;
+    constructor(seqName: string, seqOptions: CockroachSequenceOptions | undefined, schema: string | undefined);
 }
-declare function cockroachSequence(name: string, options?: CockroachSequenceOptions): CockroachSequence;
-declare function isCockroachSequence(obj: unknown): obj is CockroachSequence;
-//#endregion
-export { CockroachSequence, CockroachSequenceOptions, cockroachSequence, isCockroachSequence };
-//# sourceMappingURL=sequence.d.cts.map
+export declare function cockroachSequence(name: string, options?: CockroachSequenceOptions): CockroachSequence;
+export declare function isCockroachSequence(obj: unknown): obj is CockroachSequence;