drizzle-orm 0.28.2-8c31aee → 0.28.2-acf0b91

package/{select.types.d-7da7fae0.d.ts → select.types.d-b5ae6f28.d.ts}

@@ -1,47 +1,24 @@
-import { e as entityKind, aM as AnySQLiteTable, aF as KnownKeysOnly, aJ as ColumnsSelection, ah as Subquery, ai as WithSubquery, ax as DrizzleTypeError, X as SQLWrapper, Q as Query, a as SQL, aq as UpdateSet, aS as SQLiteTable, aL as SQLiteColumn, I as InferModel, G as GetColumnData, a9 as Param, S as Simplify, ad as Placeholder, b0 as IndexColumn, ay as ValueOrArray, aK as SQLiteColumnBuilder, o as BuildColumns, V as View, T as Table, b9 as SQLiteTableWithColumns, al as UpdateTableConfig, av as Assume, y as SelectedFieldsFlat$1, E as SelectedFields$1, F as SelectedFieldsOrdered$1 } from './column.d-04875079.js';
-import { A as AddAliasToSelection, T as TypedQueryBuilder, f as SelectResultFields, G as GetSelectTableName, a as GetSelectTableSelection, S as SelectMode, J as JoinNullability, B as BuildSubquerySelection, b as SelectResult, c as JoinType, M as MapColumnsToTableAlias, d as AppendToResult, e as AppendToNullabilityMap } from './select.types.d-f5caa4d6.js';
+import { SQLiteTable, entityKind, KnownKeysOnly, ColumnsSelection, Subquery, WithSubquery, DrizzleTypeError, AnySQLiteTable, SQLWrapper, Query, SQL, UpdateSet, SQLiteColumn, InferModel, GetColumnData, Param, Simplify, Placeholder, IndexColumn, ValueOrArray, SQLiteColumnBuilder, BuildColumns, View, Table, SQLiteTableWithColumns, UpdateTableConfig, Assume, SelectedFieldsFlat as SelectedFieldsFlat$1, SelectedFields as SelectedFields$1, SelectedFieldsOrdered as SelectedFieldsOrdered$1 } from './column.d-13e6ef37.js';
+import { AddAliasToSelection, TypedQueryBuilder, SelectResultFields, GetSelectTableName, GetSelectTableSelection, SelectMode, JoinNullability, BuildSubquerySelection, SelectResult, JoinType, MapColumnsToTableAlias, AppendToResult, AppendToNullabilityMap } from './select.types.d-c0ef8779.js';
+import { TablesRelationalConfig, TableRelationalConfig, DBQueryConfig, BuildQueryResult, QueryPromise, ExtractTablesWithRelations, RelationalSchemaConfig, Relation, BuildRelationalQueryResult } from './query-promise.d-859a27f2.js';
 import { MigrationMeta } from './migrator.js';
-import { T as TablesRelationalConfig, L as TableRelationalConfig, K as DBQueryConfig, V as BuildQueryResult, Q as QueryPromise, N as ExtractTablesWithRelations, R as RelationalSchemaConfig, a as Relation, a3 as BuildRelationalQueryResult } from './query-promise.d-31db3408.js';
 
-declare class AsyncRelationalQueryBuilder<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
-    static readonly [entityKind]: string;
-    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'async', unknown, TFullSchema, TSchema>);
-    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): SQLiteAsyncRelationalQuery<BuildQueryResult<TSchema, TFields, TConfig>[]>;
-    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): SQLiteAsyncRelationalQuery<BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
-}
-declare class SyncRelationalQueryBuilder<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
-    private fullSchema;
-    private schema;
-    private tableNamesMap;
-    private table;
-    private tableConfig;
-    private dialect;
-    private session;
+type SQLiteRelationalQueryKind<TMode extends 'sync' | 'async', TResult> = TMode extends 'async' ? SQLiteRelationalQuery<TMode, TResult> : SQLiteSyncRelationalQuery<TResult>;
+declare class RelationalQueryBuilder<TMode extends 'sync' | 'async', TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
+    protected mode: TMode;
+    protected fullSchema: Record<string, unknown>;
+    protected schema: TSchema;
+    protected tableNamesMap: Record<string, string>;
+    protected table: SQLiteTable;
+    protected tableConfig: TableRelationalConfig;
+    protected dialect: SQLiteDialect;
+    protected session: SQLiteSession<'async', unknown, TFullSchema, TSchema>;
     static readonly [entityKind]: string;
-    constructor(fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'sync', unknown, TFullSchema, TSchema>);
-    prepareFindMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): {
-        execute: PreparedQuery<PreparedQueryConfig & {
-            type: 'sync';
-            all: BuildQueryResult<TSchema, TFields, TConfig>[];
-        }>['all'];
-    };
-    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): BuildQueryResult<TSchema, TFields, TConfig>[];
-    prepareFindFirst<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): {
-        execute: PreparedQuery<PreparedQueryConfig & {
-            type: 'sync';
-            get: BuildQueryResult<TSchema, TFields, TConfig> | undefined;
-        }>['get'];
-    };
-    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): BuildQueryResult<TSchema, TFields, TSelection> | undefined;
+    constructor(mode: TMode, fullSchema: Record<string, unknown>, schema: TSchema, tableNamesMap: Record<string, string>, table: SQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'async', unknown, TFullSchema, TSchema>);
+    findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>): SQLiteRelationalQueryKind<TMode, BuildQueryResult<TSchema, TFields, TConfig>[]>;
+    findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>): SQLiteRelationalQueryKind<TMode, BuildQueryResult<TSchema, TFields, TSelection> | undefined>;
 }
-declare class SQLiteRelationalQuery<TResultKind extends 'sync' | 'async', TResult> {
+declare class SQLiteRelationalQuery<TType extends 'sync' | 'async', TResult> extends QueryPromise<TResult> {
     private fullSchema;
     private schema;
     private tableNamesMap;
@@ -53,15 +30,18 @@ declare class SQLiteRelationalQuery<TResultKind extends 'sync' | 'async', TResul
     private mode;
     static readonly [entityKind]: string;
     protected $brand: 'SQLiteRelationalQuery';
-    constructor(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: AnySQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<TResultKind, unknown, Record<string, unknown>, TablesRelationalConfig>, config: DBQueryConfig<'many', true> | true, mode: 'many' | 'first');
+    constructor(fullSchema: Record<string, unknown>, schema: TablesRelationalConfig, tableNamesMap: Record<string, string>, table: SQLiteTable, tableConfig: TableRelationalConfig, dialect: SQLiteDialect, session: SQLiteSession<'sync' | 'async', unknown, Record<string, unknown>, TablesRelationalConfig>, config: DBQueryConfig<'many', true> | true, mode: 'many' | 'first');
     prepare(): PreparedQuery<PreparedQueryConfig & {
-        type: TResultKind;
+        type: TType;
         all: TResult;
         get: TResult;
+        execute: TResult;
     }>;
-    execute(): Result<TResultKind, TResult>;
+    execute(): Promise<TResult>;
 }
-interface SQLiteAsyncRelationalQuery<TResult> extends SQLiteRelationalQuery<'async', TResult>, QueryPromise<TResult> {
+declare class SQLiteSyncRelationalQuery<TResult> extends SQLiteRelationalQuery<'sync', TResult> {
+    static readonly [entityKind]: string;
+    sync(): TResult;
 }
 
 type SubqueryWithSelection<TSelection extends ColumnsSelection, TAlias extends string> = Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'sqlite'>> & AddAliasToSelection<TSelection, TAlias, 'sqlite'>;
@@ -74,7 +54,7 @@ declare class BaseSQLiteDatabase<TResultKind extends 'sync' | 'async', TRunResul
         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]: TResultKind extends 'async' ? AsyncRelationalQueryBuilder<TFullSchema, TSchema, TSchema[K]> : SyncRelationalQueryBuilder<TFullSchema, TSchema, TSchema[K]>;
+        [K in keyof TSchema]: RelationalQueryBuilder<TResultKind, TFullSchema, TSchema, TSchema[K]>;
     };
     constructor(resultKind: TResultKind, 
     /** @internal */
@@ -114,20 +94,34 @@ declare class BaseSQLiteDatabase<TResultKind extends 'sync' | 'async', TRunResul
 interface PreparedQueryConfig {
     type: 'sync' | 'async';
     run: unknown;
-    all: unknown[];
+    all: unknown;
     get: unknown;
-    values: unknown[][];
+    values: unknown;
+    execute: unknown;
 }
+declare class ExecuteResultSync<T> extends QueryPromise<T> {
+    private resultCb;
+    static readonly [entityKind]: string;
+    constructor(resultCb: () => T);
+    execute(): Promise<T>;
+    sync(): T;
+}
+type ExecuteResult<TType extends 'sync' | 'async', TResult> = TType extends 'async' ? Promise<TResult> : ExecuteResultSync<TResult>;
 declare abstract class PreparedQuery<T extends PreparedQueryConfig> {
+    private mode;
+    private executeMethod;
     static readonly [entityKind]: string;
+    constructor(mode: 'sync' | 'async', executeMethod: SQLiteExecuteMethod);
     abstract run(placeholderValues?: Record<string, unknown>): Result<T['type'], T['run']>;
     abstract all(placeholderValues?: Record<string, unknown>): Result<T['type'], T['all']>;
     abstract get(placeholderValues?: Record<string, unknown>): Result<T['type'], T['get']>;
     abstract values(placeholderValues?: Record<string, unknown>): Result<T['type'], T['values']>;
+    execute(placeholderValues?: Record<string, unknown>): ExecuteResult<T['type'], T['execute']>;
 }
 interface SQLiteTransactionConfig {
     behavior?: 'deferred' | 'immediate' | 'exclusive';
 }
+type SQLiteExecuteMethod = 'run' | 'all' | 'get';
 declare abstract class SQLiteSession<TResultKind extends 'sync' | 'async', TRunResult, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> {
     static readonly [entityKind]: string;
     constructor(
@@ -136,10 +130,10 @@ declare abstract class SQLiteSession<TResultKind extends 'sync' | 'async', TRunR
         sync: SQLiteSyncDialect;
         async: SQLiteAsyncDialect;
     }[TResultKind]);
-    abstract prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown): PreparedQuery<PreparedQueryConfig & {
+    abstract prepareQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown): PreparedQuery<PreparedQueryConfig & {
         type: TResultKind;
     }>;
-    prepareOneTimeQuery(query: Query, fields: SelectedFieldsOrdered | undefined): PreparedQuery<PreparedQueryConfig & {
+    prepareOneTimeQuery(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod): PreparedQuery<PreparedQueryConfig & {
         type: TResultKind;
     }>;
     abstract transaction<T>(transaction: (tx: SQLiteTransaction<TResultKind, TRunResult, TFullSchema, TSchema>) => Result<TResultKind, T>, config?: SQLiteTransactionConfig): Result<TResultKind, T>;
@@ -232,7 +226,7 @@ interface SQLiteDeleteConfig {
 }
 interface SQLiteDelete<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper {
 }
-declare class SQLiteDelete<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> implements SQLWrapper {
+declare class SQLiteDelete<TTable extends SQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
     private table;
     private session;
     private dialect;
@@ -240,20 +234,22 @@ declare class SQLiteDelete<TTable extends SQLiteTable, TResultType extends 'sync
     private config;
     constructor(table: TTable, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
     where(where: SQL | undefined): Omit<this, 'where'>;
-    returning(): Omit<SQLiteDelete<TTable, TResultType, TRunResult, InferModel<TTable>>, 'where' | 'returning'>;
-    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): Omit<SQLiteDelete<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>, 'where' | 'returning'>;
+    returning(): SQLiteDelete<TTable, TResultType, TRunResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): SQLiteDelete<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>;
     toSQL(): Omit<Query, 'typings'>;
     prepare(isOneTimeQuery?: boolean): PreparedQuery<{
         type: TResultType;
         run: TRunResult;
-        all: TReturning extends undefined ? never : TReturning[];
-        get: TReturning extends undefined ? never : TReturning | undefined;
-        values: TReturning extends undefined ? never : any[][];
+        all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
+        get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning | undefined;
+        values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'> : any[][];
+        execute: TReturning extends undefined ? TRunResult : TReturning[];
     }>;
     run: ReturnType<this['prepare']>['run'];
     all: ReturnType<this['prepare']>['all'];
     get: ReturnType<this['prepare']>['get'];
     values: ReturnType<this['prepare']>['values'];
+    execute(placeholderValues?: Record<string, unknown>): Promise<TReturning extends undefined ? TRunResult : TReturning[]>;
 }
 
 interface SQLiteUpdateConfig {
@@ -276,9 +272,9 @@ declare class SQLiteUpdateBuilder<TTable extends AnySQLiteTable, TResultType ext
     constructor(table: TTable, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
     set(values: SQLiteUpdateSetSource<TTable>): SQLiteUpdate<TTable, TResultType, TRunResult>;
 }
-interface SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper {
+interface SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {
 }
-declare class SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> implements SQLWrapper {
+declare class SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
     private session;
     private dialect;
     static readonly [entityKind]: string;
@@ -288,8 +284,8 @@ declare class SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 's
     private config;
     constructor(table: TTable, set: UpdateSet, session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
     where(where: SQL | undefined): Omit<this, 'where'>;
-    returning(): Omit<SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>, 'where' | 'returning'>;
-    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): Omit<SQLiteUpdate<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>, 'where' | 'returning'>;
+    returning(): SQLiteUpdate<TTable, TResultType, TRunResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFields>(fields: TSelectedFields): SQLiteUpdate<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>;
     toSQL(): {
         sql: Query['sql'];
         params: Query['params'];
@@ -297,14 +293,16 @@ declare class SQLiteUpdate<TTable extends AnySQLiteTable, TResultType extends 's
     prepare(isOneTimeQuery?: boolean): PreparedQuery<{
         type: TResultType;
         run: TRunResult;
-        all: TReturning extends undefined ? never : TReturning[];
-        get: TReturning extends undefined ? never : TReturning;
-        values: TReturning extends undefined ? never : any[][];
+        all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
+        get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning;
+        values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'> : any[][];
+        execute: TReturning extends undefined ? TRunResult : TReturning[];
     }>;
     run: ReturnType<this['prepare']>['run'];
     all: ReturnType<this['prepare']>['all'];
     get: ReturnType<this['prepare']>['get'];
     values: ReturnType<this['prepare']>['values'];
+    execute(): Promise<TReturning extends undefined ? TRunResult : TReturning[]>;
 }
 
 interface SQLiteInsertConfig<TTable extends AnySQLiteTable = AnySQLiteTable> {
@@ -325,9 +323,9 @@ declare class SQLiteInsertBuilder<TTable extends AnySQLiteTable, TResultType ext
     values(value: SQLiteInsertValue<TTable>): SQLiteInsert<TTable, TResultType, TRunResult>;
     values(values: SQLiteInsertValue<TTable>[]): SQLiteInsert<TTable, TResultType, TRunResult>;
 }
-interface SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper {
+interface SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends SQLWrapper, QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> {
 }
-declare class SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> implements SQLWrapper {
+declare class SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 'sync' | 'async', TRunResult, TReturning = undefined> extends QueryPromise<TReturning extends undefined ? TRunResult : TReturning[]> implements SQLWrapper {
     private session;
     private dialect;
     static readonly [entityKind]: string;
@@ -339,8 +337,8 @@ declare class SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 's
     };
     private config;
     constructor(table: TTable, values: SQLiteInsertConfig['values'], session: SQLiteSession<any, any, any, any>, dialect: SQLiteDialect);
-    returning(): Omit<SQLiteInsert<TTable, TResultType, TRunResult, InferModel<TTable>>, 'returning' | `onConflict${string}`>;
-    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): Omit<SQLiteInsert<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>, 'returning' | `onConflict${string}`>;
+    returning(): SQLiteInsert<TTable, TResultType, TRunResult, InferModel<TTable>>;
+    returning<TSelectedFields extends SelectedFieldsFlat>(fields: TSelectedFields): SQLiteInsert<TTable, TResultType, TRunResult, SelectResultFields<TSelectedFields>>;
     onConflictDoNothing(config?: {
         target?: IndexColumn | IndexColumn[];
         where?: SQL;
@@ -357,14 +355,16 @@ declare class SQLiteInsert<TTable extends AnySQLiteTable, TResultType extends 's
     prepare(isOneTimeQuery?: boolean): PreparedQuery<{
         type: TResultType;
         run: TRunResult;
-        all: TReturning extends undefined ? never : TReturning[];
-        get: TReturning extends undefined ? never : TReturning;
-        values: TReturning extends undefined ? never : any[][];
+        all: TReturning extends undefined ? DrizzleTypeError<'.all() cannot be used without .returning()'> : TReturning[];
+        get: TReturning extends undefined ? DrizzleTypeError<'.get() cannot be used without .returning()'> : TReturning;
+        values: TReturning extends undefined ? DrizzleTypeError<'.values() cannot be used without .returning()'> : any[][];
+        execute: TReturning extends undefined ? TRunResult : TReturning[];
     }>;
     run: ReturnType<this['prepare']>['run'];
     all: ReturnType<this['prepare']>['all'];
     get: ReturnType<this['prepare']>['get'];
     values: ReturnType<this['prepare']>['values'];
+    execute(): Promise<TReturning extends undefined ? TRunResult : TReturning[]>;
 }
 
 type CreateSQLiteSelectFromBuilderMode<TBuilderMode extends 'db' | 'qb', TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode> = TBuilderMode extends 'db' ? SQLiteSelect<TTableName, TResultType, TRunResult, TSelection, TSelectMode> : SQLiteSelectQueryBuilder<SQLiteSelectQueryBuilderHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode>;
@@ -427,7 +427,7 @@ declare abstract class SQLiteSelectQueryBuilder<THKT extends SQLiteSelectHKTBase
     as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<BuildSubquerySelection<TSelection, TNullabilityMap>, TAlias>;
     getSelectedFields(): BuildSubquerySelection<TSelection, TNullabilityMap>;
 }
-interface SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName | undefined, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
+interface SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName | undefined, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap>, QueryPromise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]> {
 }
 declare class SQLiteSelect<TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection, TSelectMode extends SelectMode = 'single', TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}> extends SQLiteSelectQueryBuilder<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap> {
     static readonly [entityKind]: string;
@@ -437,11 +437,13 @@ declare class SQLiteSelect<TTableName extends string | undefined, TResultType ex
         all: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
         get: SelectResult<TSelection, TSelectMode, TNullabilityMap> | undefined;
         values: any[][];
+        execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[];
     }>;
     run: ReturnType<this['prepare']>['run'];
     all: ReturnType<this['prepare']>['all'];
     get: ReturnType<this['prepare']>['get'];
     values: ReturnType<this['prepare']>['values'];
+    execute(): Promise<SelectResult<TSelection, TSelectMode, TNullabilityMap>[]>;
 }
 
 declare class QueryBuilder {
@@ -579,4 +581,4 @@ interface SQLiteSelectHKT extends SQLiteSelectHKTBase {
     _type: SQLiteSelect<this['tableName'], this['resultType'], this['runResult'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
 }
 
-export { AnySQLiteSelect as A, BaseSQLiteDatabase as B, SQLiteSelectHKT as C, SQLiteUpdateConfig as D, SQLiteUpdateSetSource as E, SQLiteUpdateBuilder as F, SQLiteUpdate as G, SubqueryWithSelection as H, ViewBuilderCore as I, Join as J, ViewBuilder as K, SQLiteViewConfig as L, ManualViewBuilder as M, SQLiteViewWithSelection as N, sqliteView as O, PreparedQuery as P, QueryBuilder as Q, Result as R, SQLiteSession as S, view as T, ViewBuilderConfig as V, WithSubqueryWithSelection as W, SQLiteSyncDialect as a, SelectedFieldsOrdered as b, SQLiteTransactionConfig as c, SQLiteTransaction as d, PreparedQueryConfig as e, SQLiteAsyncDialect as f, SQLiteView as g, SQLiteViewBase as h, BuildAliasTable as i, SQLiteDialect as j, SQLiteDeleteConfig as k, SQLiteDelete as l, SQLiteInsertConfig as m, SQLiteInsertValue as n, SQLiteInsertBuilder as o, SQLiteInsert as p, SQLiteSelectBuilder as q, SQLiteSelectQueryBuilder as r, SQLiteSelect as s, SQLiteSelectConfig as t, JoinFn as u, SelectedFieldsFlat as v, SelectedFields as w, SQLiteSelectHKTBase as x, SQLiteSelectKind as y, SQLiteSelectQueryBuilderHKT as z };
+export { AnySQLiteSelect, BaseSQLiteDatabase, BuildAliasTable, ExecuteResult, ExecuteResultSync, Join, JoinFn, ManualViewBuilder, PreparedQuery, PreparedQueryConfig, QueryBuilder, Result, SQLiteAsyncDialect, SQLiteDelete, SQLiteDeleteConfig, SQLiteDialect, SQLiteExecuteMethod, SQLiteInsert, SQLiteInsertBuilder, SQLiteInsertConfig, SQLiteInsertValue, SQLiteSelect, SQLiteSelectBuilder, SQLiteSelectConfig, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectKind, SQLiteSelectQueryBuilder, SQLiteSelectQueryBuilderHKT, SQLiteSession, SQLiteSyncDialect, SQLiteTransaction, SQLiteTransactionConfig, SQLiteUpdate, SQLiteUpdateBuilder, SQLiteUpdateConfig, SQLiteUpdateSetSource, SQLiteView, SQLiteViewBase, SQLiteViewConfig, SQLiteViewWithSelection, SelectedFields, SelectedFieldsFlat, SelectedFieldsOrdered, SubqueryWithSelection, ViewBuilder, ViewBuilderConfig, ViewBuilderCore, WithSubqueryWithSelection, sqliteView, view };

package/{select.types.d-f5caa4d6.d.ts → select.types.d-c0ef8779.d.ts}

@@ -1,4 +1,4 @@
-import { X as SQLWrapper, e as entityKind, a as SQL, an as AnyTable, C as Column, A as AnyColumn, aJ as ColumnsSelection, h as Dialect, p as ChangeColumnTableName, av as Assume, S as Simplify, aH as IsAny, E as SelectedFields, T as Table, ax as DrizzleTypeError, ah as Subquery, V as View, aw as Equal, G as GetColumnData, U as UpdateColConfig } from './column.d-04875079.js';
+import { SQLWrapper, entityKind, SQL, AnyTable, Column, AnyColumn, ColumnsSelection, Dialect, ChangeColumnTableName, Assume, Simplify, IsAny, SelectedFields, Table, DrizzleTypeError, Subquery, View, Equal, GetColumnData, UpdateColConfig } from './column.d-13e6ef37.js';
 
 declare abstract class TypedQueryBuilder<TSelection, TResult = unknown> implements SQLWrapper {
     static readonly [entityKind]: string;
@@ -52,9 +52,9 @@ type AppendToNullabilityMap<TJoinsNotNull extends Record<string, JoinNullability
 type TableLike = Table | Subquery | View | SQL;
 type GetSelectTableName<TTable extends TableLike> = TTable extends Table ? TTable['_']['name'] : TTable extends Subquery ? TTable['_']['alias'] : TTable extends View ? TTable['_']['name'] : TTable extends SQL ? undefined : never;
 type GetSelectTableSelection<TTable extends TableLike> = TTable extends Table ? TTable['_']['columns'] : TTable extends Subquery | View ? Assume<TTable['_']['selectedFields'], ColumnsSelection> : TTable extends SQL ? {} : never;
-type SelectResultField<T, TDeep extends boolean = true> = T extends DrizzleTypeError<any> ? T : T extends Table ? Equal<TDeep, true> extends true ? SelectResultField<T['_']['columns'], false> : never : T extends Column ? GetColumnData<T> : T extends SQL | SQL.Aliased ? T['_']['type'] : T extends Record<string, any> ? SelectResultFields<T, true> : never;
+type SelectResultField<T, TDeep extends boolean = true> = T extends DrizzleTypeError<any> ? T : T extends Table ? Equal<TDeep, true> extends true ? SelectResultField<T['_']['columns'], false> : never : T extends Column<any> ? GetColumnData<T> : T extends SQL | SQL.Aliased ? T['_']['type'] : T extends Record<string, any> ? SelectResultFields<T, true> : never;
 type SelectResultFields<TSelectedFields, TDeep extends boolean = true> = {
     [Key in keyof TSelectedFields & string]: SelectResultField<TSelectedFields[Key], TDeep>;
 } & {};
 
-export { AddAliasToSelection as A, BuildSubquerySelection as B, GetSelectTableName as G, JoinNullability as J, MapColumnsToTableAlias as M, SelectMode as S, TypedQueryBuilder as T, GetSelectTableSelection as a, SelectResult as b, JoinType as c, AppendToResult as d, AppendToNullabilityMap as e, SelectResultFields as f };
+export { AddAliasToSelection, AppendToNullabilityMap, AppendToResult, BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, JoinType, MapColumnsToTableAlias, SelectMode, SelectResult, SelectResultFields, TypedQueryBuilder };

package/{select.types.d-3ce070d1.d.ts → select.types.d-f4c3cdca.d.ts}

@@ -1,6 +1,6 @@
-import { e as entityKind, bm as AnyPgTable, aF as KnownKeysOnly, Q as Query, aJ as ColumnsSelection, ah as Subquery, ai as WithSubquery, ax as DrizzleTypeError, bn as AnyPgColumn, X as SQLWrapper, a as SQL, aq as UpdateSet, a3 as DriverValueEncoder, W as QueryTypingsValue, bo as PgColumn, I as InferModel, G as GetColumnData, a9 as Param, ad as Placeholder, bp as IndexColumn, ay as ValueOrArray, bq as PgColumnBuilder, o as BuildColumns, br as AnyPgColumnBuilder, V as View, bs as PgTable, T as Table, bt as PgTableWithColumns, al as UpdateTableConfig, av as Assume, y as SelectedFieldsFlat$1, E as SelectedFields$1, F as SelectedFieldsOrdered$1 } from './column.d-04875079.js';
-import { A as AddAliasToSelection, T as TypedQueryBuilder, f as SelectResultFields, G as GetSelectTableName, a as GetSelectTableSelection, S as SelectMode, J as JoinNullability, B as BuildSubquerySelection, b as SelectResult, c as JoinType, M as MapColumnsToTableAlias, d as AppendToResult, e as AppendToNullabilityMap } from './select.types.d-f5caa4d6.js';
-import { T as TablesRelationalConfig, L as TableRelationalConfig, K as DBQueryConfig, V as BuildQueryResult, Q as QueryPromise, N as ExtractTablesWithRelations, R as RelationalSchemaConfig, a as Relation, a3 as BuildRelationalQueryResult } from './query-promise.d-31db3408.js';
+import { entityKind, AnyPgTable, KnownKeysOnly, Query, ColumnsSelection, Subquery, WithSubquery, DrizzleTypeError, AnyPgColumn, SQLWrapper, SQL, UpdateSet, DriverValueEncoder, QueryTypingsValue, PgColumn, InferModel, GetColumnData, Param, Placeholder, IndexColumn$1 as IndexColumn, ValueOrArray, PgColumnBuilder, BuildColumns, AnyPgColumnBuilder, View, PgTable, Table, PgTableWithColumns, UpdateTableConfig, Assume, SelectedFieldsFlat as SelectedFieldsFlat$1, SelectedFields as SelectedFields$1, SelectedFieldsOrdered as SelectedFieldsOrdered$1 } from './column.d-13e6ef37.js';
+import { AddAliasToSelection, TypedQueryBuilder, SelectResultFields, GetSelectTableName, GetSelectTableSelection, SelectMode, JoinNullability, BuildSubquerySelection, SelectResult, JoinType, MapColumnsToTableAlias, AppendToResult, AppendToNullabilityMap } from './select.types.d-c0ef8779.js';
+import { TablesRelationalConfig, TableRelationalConfig, DBQueryConfig, BuildQueryResult, QueryPromise, ExtractTablesWithRelations, RelationalSchemaConfig, Relation, BuildRelationalQueryResult } from './query-promise.d-859a27f2.js';
 import { MigrationMeta } from './migrator.js';
 
 declare class RelationalQueryBuilder<TSchema extends TablesRelationalConfig, TFields extends TableRelationalConfig> {
@@ -740,4 +740,4 @@ interface PgSelectHKT extends PgSelectHKTBase {
     _type: PgSelect<this['tableName'], Assume<this['selection'], ColumnsSelection>, this['selectMode'], Assume<this['nullabilityMap'], Record<string, JoinNullability>>>;
 }
 
-export { PgViewConfig as $, AnyPgSelect as A, BuildAliasTable as B, PgUpdateConfig as C, PgUpdateSetSource as D, PgUpdateBuilder as E, PgUpdate as F, PreparedQueryConfig as G, PreparedQuery as H, PgTransactionConfig as I, Join as J, PgSession as K, LockStrength as L, PgTransaction as M, QueryResultHKT as N, QueryResultKind as O, PgViewBase as P, QueryBuilder as Q, SubqueryWithSelection as R, SelectedFieldsFlat as S, DefaultViewBuilderCore as T, ViewBuilder as U, ViewWithConfig as V, WithSubqueryWithSelection as W, ManualViewBuilder as X, MaterializedViewBuilderCore as Y, MaterializedViewBuilder as Z, ManualMaterializedViewBuilder as _, pgMaterializedView as a, PgViewWithSelection as a0, PgMaterializedViewConfig as a1, PgMaterializedViewWithSelection as a2, PgView as b, PgMaterializedView as c, PgMaterializedViewWithConfig as d, PgDatabase as e, PgDialect as f, PgDeleteConfig as g, PgDelete as h, PgInsertConfig as i, PgInsertValue as j, PgInsertBuilder as k, PgInsert as l, PgRefreshMaterializedView as m, PgSelectBuilder as n, PgSelectQueryBuilder as o, pgView as p, PgSelect as q, PgSelectConfig as r, JoinFn as s, SelectedFields as t, SelectedFieldsOrdered as u, LockConfig as v, PgSelectHKTBase as w, PgSelectKind as x, PgSelectQueryBuilderHKT as y, PgSelectHKT as z };
+export { AnyPgSelect, BuildAliasTable, DefaultViewBuilderCore, Join, JoinFn, LockConfig, LockStrength, ManualMaterializedViewBuilder, ManualViewBuilder, MaterializedViewBuilder, MaterializedViewBuilderCore, PgDatabase, PgDelete, PgDeleteConfig, PgDialect, PgInsert, PgInsertBuilder, PgInsertConfig, PgInsertValue, PgMaterializedView, PgMaterializedViewConfig, PgMaterializedViewWithConfig, PgMaterializedViewWithSelection, PgRefreshMaterializedView, PgSelect, PgSelectBuilder, PgSelectConfig, PgSelectHKT, PgSelectHKTBase, PgSelectKind, PgSelectQueryBuilder, PgSelectQueryBuilderHKT, PgSession, PgTransaction, PgTransactionConfig, PgUpdate, PgUpdateBuilder, PgUpdateConfig, PgUpdateSetSource, PgView, PgViewBase, PgViewConfig, PgViewWithSelection, PreparedQuery, PreparedQueryConfig, QueryBuilder, QueryResultHKT, QueryResultKind, SelectedFields, SelectedFieldsFlat, SelectedFieldsOrdered, SubqueryWithSelection, ViewBuilder, ViewWithConfig, WithSubqueryWithSelection, pgMaterializedView, pgView };