drizzle-orm 0.29.3 → 0.29.4-b475b53

package/sqlite-core/query-builders/select.d.cts

@@ -4,16 +4,16 @@ import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelectio
 import { QueryPromise } from "../../query-promise.cjs";
 import type { RunnableQuery } from "../../runnable-query.cjs";
 import { SQL } from "../../sql/sql.cjs";
-import type { ColumnsSelection, Placeholder, Query } from "../../sql/sql.cjs";
+import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from "../../sql/sql.cjs";
 import type { SQLiteColumn } from "../columns/index.cjs";
 import type { SQLiteDialect } from "../dialect.cjs";
 import type { SQLiteSession } from "../session.cjs";
 import type { SubqueryWithSelection } from "../subquery.cjs";
 import type { SQLiteTable } from "../table.cjs";
-import { type ValueOrArray } from "../../utils.cjs";
-import type { CreateSQLiteSelectFromBuilderMode, GetSQLiteSetOperators, SelectedFields, SetOperatorRightSelect, SQLiteCreateSetOperatorFn, SQLiteJoinFn, SQLiteSelectConfig, SQLiteSelectDynamic, SQLiteSelectExecute, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectPrepare, SQLiteSelectWithout, SQLiteSetOperatorExcludedMethods, SQLiteSetOperatorWithResult } from "./select.types.cjs";
 import { Subquery } from "../../subquery.cjs";
+import { type ValueOrArray } from "../../utils.cjs";
 import { SQLiteViewBase } from "../view-base.cjs";
+import type { CreateSQLiteSelectFromBuilderMode, GetSQLiteSetOperators, SelectedFields, SetOperatorRightSelect, SQLiteCreateSetOperatorFn, SQLiteJoinFn, SQLiteSelectConfig, SQLiteSelectDynamic, SQLiteSelectExecute, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectPrepare, SQLiteSelectWithout, SQLiteSetOperatorExcludedMethods, SQLiteSetOperatorWithResult } from "./select.types.cjs";
 export declare class SQLiteSelectBuilder<TSelection extends SelectedFields | undefined, TResultType extends 'sync' | 'async', TRunResult, TBuilderMode extends 'db' | 'qb' = 'db'> {
     static readonly [entityKind]: string;
     private fields;
@@ -33,7 +33,7 @@ export declare class SQLiteSelectBuilder<TSelection extends SelectedFields | und
 export declare abstract class SQLiteSelectQueryBuilderBase<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends TypedQueryBuilder<TSelectedFields, TResult> {
     static readonly [entityKind]: string;
     readonly _: {
-        dialect: 'sqlite';
+        readonly dialect: 'sqlite';
         readonly hkt: THKT;
         readonly tableName: TTableName;
         readonly resultType: TResultType;
@@ -306,7 +306,7 @@ export declare abstract class SQLiteSelectQueryBuilderBase<THKT extends SQLiteSe
      * // Select all cars with the green or blue color
      * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
      * ```
-    */
+     */
     where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): SQLiteSelectWithout<this, TDynamic, 'where'>;
     /**
      * Adds a `having` clause to the query.
@@ -418,9 +418,9 @@ export declare abstract class SQLiteSelectQueryBuilderBase<THKT extends SQLiteSe
 }
 export interface SQLiteSelectBase<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'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends SQLiteSelectQueryBuilderBase<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields>, QueryPromise<TResult> {
 }
-export declare class SQLiteSelectBase<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'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends SQLiteSelectQueryBuilderBase<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields> implements RunnableQuery<TResult, 'sqlite'> {
+export declare class SQLiteSelectBase<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'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends SQLiteSelectQueryBuilderBase<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields> implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper {
     static readonly [entityKind]: string;
-    prepare(isOneTimeQuery?: boolean): SQLiteSelectPrepare<this>;
+    prepare(): SQLiteSelectPrepare<this>;
     run: ReturnType<this['prepare']>['run'];
     all: ReturnType<this['prepare']>['all'];
     get: ReturnType<this['prepare']>['get'];

package/sqlite-core/query-builders/select.d.ts

@@ -4,16 +4,16 @@ import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelectio
 import { QueryPromise } from "../../query-promise.js";
 import type { RunnableQuery } from "../../runnable-query.js";
 import { SQL } from "../../sql/sql.js";
-import type { ColumnsSelection, Placeholder, Query } from "../../sql/sql.js";
+import type { ColumnsSelection, Placeholder, Query, SQLWrapper } from "../../sql/sql.js";
 import type { SQLiteColumn } from "../columns/index.js";
 import type { SQLiteDialect } from "../dialect.js";
 import type { SQLiteSession } from "../session.js";
 import type { SubqueryWithSelection } from "../subquery.js";
 import type { SQLiteTable } from "../table.js";
-import { type ValueOrArray } from "../../utils.js";
-import type { CreateSQLiteSelectFromBuilderMode, GetSQLiteSetOperators, SelectedFields, SetOperatorRightSelect, SQLiteCreateSetOperatorFn, SQLiteJoinFn, SQLiteSelectConfig, SQLiteSelectDynamic, SQLiteSelectExecute, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectPrepare, SQLiteSelectWithout, SQLiteSetOperatorExcludedMethods, SQLiteSetOperatorWithResult } from "./select.types.js";
 import { Subquery } from "../../subquery.js";
+import { type ValueOrArray } from "../../utils.js";
 import { SQLiteViewBase } from "../view-base.js";
+import type { CreateSQLiteSelectFromBuilderMode, GetSQLiteSetOperators, SelectedFields, SetOperatorRightSelect, SQLiteCreateSetOperatorFn, SQLiteJoinFn, SQLiteSelectConfig, SQLiteSelectDynamic, SQLiteSelectExecute, SQLiteSelectHKT, SQLiteSelectHKTBase, SQLiteSelectPrepare, SQLiteSelectWithout, SQLiteSetOperatorExcludedMethods, SQLiteSetOperatorWithResult } from "./select.types.js";
 export declare class SQLiteSelectBuilder<TSelection extends SelectedFields | undefined, TResultType extends 'sync' | 'async', TRunResult, TBuilderMode extends 'db' | 'qb' = 'db'> {
     static readonly [entityKind]: string;
     private fields;
@@ -33,7 +33,7 @@ export declare class SQLiteSelectBuilder<TSelection extends SelectedFields | und
 export declare abstract class SQLiteSelectQueryBuilderBase<THKT extends SQLiteSelectHKTBase, TTableName extends string | undefined, TResultType extends 'sync' | 'async', TRunResult, TSelection extends ColumnsSelection, TSelectMode extends SelectMode, TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends TypedQueryBuilder<TSelectedFields, TResult> {
     static readonly [entityKind]: string;
     readonly _: {
-        dialect: 'sqlite';
+        readonly dialect: 'sqlite';
         readonly hkt: THKT;
         readonly tableName: TTableName;
         readonly resultType: TResultType;
@@ -306,7 +306,7 @@ export declare abstract class SQLiteSelectQueryBuilderBase<THKT extends SQLiteSe
      * // Select all cars with the green or blue color
      * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
      * ```
-    */
+     */
     where(where: ((aliases: TSelection) => SQL | undefined) | SQL | undefined): SQLiteSelectWithout<this, TDynamic, 'where'>;
     /**
      * Adds a `having` clause to the query.
@@ -418,9 +418,9 @@ export declare abstract class SQLiteSelectQueryBuilderBase<THKT extends SQLiteSe
 }
 export interface SQLiteSelectBase<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'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends SQLiteSelectQueryBuilderBase<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields>, QueryPromise<TResult> {
 }
-export declare class SQLiteSelectBase<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'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends SQLiteSelectQueryBuilderBase<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields> implements RunnableQuery<TResult, 'sqlite'> {
+export declare class SQLiteSelectBase<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'> : {}, TDynamic extends boolean = false, TExcludedMethods extends string = never, TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[], TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>> extends SQLiteSelectQueryBuilderBase<SQLiteSelectHKT, TTableName, TResultType, TRunResult, TSelection, TSelectMode, TNullabilityMap, TDynamic, TExcludedMethods, TResult, TSelectedFields> implements RunnableQuery<TResult, 'sqlite'>, SQLWrapper {
     static readonly [entityKind]: string;
-    prepare(isOneTimeQuery?: boolean): SQLiteSelectPrepare<this>;
+    prepare(): SQLiteSelectPrepare<this>;
     run: ReturnType<this['prepare']>['run'];
     all: ReturnType<this['prepare']>['all'];
     get: ReturnType<this['prepare']>['get'];

package/sqlite-core/query-builders/select.js

@@ -1,7 +1,9 @@
 import { entityKind, is } from "../../entity.js";
 import { TypedQueryBuilder } from "../../query-builders/query-builder.js";
 import { QueryPromise } from "../../query-promise.js";
+import { SelectionProxyHandler } from "../../selection-proxy.js";
 import { SQL, View } from "../../sql/sql.js";
+import { Subquery, SubqueryConfig } from "../../subquery.js";
 import { Table } from "../../table.js";
 import {
   applyMixins,
@@ -11,9 +13,7 @@ import {
   orderSelectedFields
 } from "../../utils.js";
 import { ViewBaseConfig } from "../../view-common.js";
-import { Subquery, SubqueryConfig } from "../../subquery.js";
 import { SQLiteViewBase } from "../view-base.js";
-import { SelectionProxyHandler } from "../../selection-proxy.js";
 class SQLiteSelectBuilder {
   static [entityKind] = "SQLiteSelectBuilder";
   fields;
@@ -144,22 +144,22 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   }
   /**
    * Executes a `left join` operation by adding another table to the current query.
-   * 
+   *
    * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
-   * 
+   *
    * @param table the table to join.
    * @param on the `on` clause.
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all users and their pets
    * const usersWithPets: { user: User; pets: Pet | null }[] = await db.select()
    *   .from(users)
    *   .leftJoin(pets, eq(users.id, pets.ownerId))
-   * 
+   *
    * // Select userId and petId
    * const usersIdsAndPetIds: { userId: number; petId: number | null }[] = await db.select({
    *   userId: users.id,
@@ -172,22 +172,22 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   leftJoin = this.createJoin("left");
   /**
    * Executes a `right join` operation by adding another table to the current query.
-   * 
+   *
    * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
-   * 
+   *
    * @param table the table to join.
    * @param on the `on` clause.
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all users and their pets
    * const usersWithPets: { user: User | null; pets: Pet }[] = await db.select()
    *   .from(users)
    *   .rightJoin(pets, eq(users.id, pets.ownerId))
-   * 
+   *
    * // Select userId and petId
    * const usersIdsAndPetIds: { userId: number | null; petId: number }[] = await db.select({
    *   userId: users.id,
@@ -200,22 +200,22 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   rightJoin = this.createJoin("right");
   /**
    * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
-   * 
+   *
    * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
-   * 
+   *
    * @param table the table to join.
    * @param on the `on` clause.
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all users and their pets
    * const usersWithPets: { user: User; pets: Pet }[] = await db.select()
    *   .from(users)
    *   .innerJoin(pets, eq(users.id, pets.ownerId))
-   * 
+   *
    * // Select userId and petId
    * const usersIdsAndPetIds: { userId: number; petId: number }[] = await db.select({
    *   userId: users.id,
@@ -228,22 +228,22 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   innerJoin = this.createJoin("inner");
   /**
    * Executes a `full join` operation by combining rows from two tables into a new table.
-   * 
+   *
    * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
-   * 
+   *
    * @param table the table to join.
    * @param on the `on` clause.
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all users and their pets
    * const usersWithPets: { user: User | null; pets: Pet | null }[] = await db.select()
    *   .from(users)
    *   .fullJoin(pets, eq(users.id, pets.ownerId))
-   * 
+   *
    * // Select userId and petId
    * const usersIdsAndPetIds: { userId: number | null; petId: number | null }[] = await db.select({
    *   userId: users.id,
@@ -268,13 +268,13 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   }
   /**
    * Adds `union` set operator to the query.
-   * 
+   *
    * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all unique names from customers and users tables
    * await db.select({ name: users.name })
@@ -284,9 +284,9 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
    *   );
    * // or
    * import { union } from 'drizzle-orm/sqlite-core'
-   * 
+   *
    * await union(
-   *   db.select({ name: users.name }).from(users), 
+   *   db.select({ name: users.name }).from(users),
    *   db.select({ name: customers.name }).from(customers)
    * );
    * ```
@@ -294,13 +294,13 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   union = this.createSetOperator("union", false);
   /**
    * Adds `union all` set operator to the query.
-   * 
+   *
    * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all transaction ids from both online and in-store sales
    * await db.select({ transaction: onlineSales.transactionId })
@@ -310,7 +310,7 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
    *   );
    * // or
    * import { unionAll } from 'drizzle-orm/sqlite-core'
-   * 
+   *
    * await unionAll(
    *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
    *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
@@ -320,13 +320,13 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   unionAll = this.createSetOperator("union", true);
   /**
    * Adds `intersect` set operator to the query.
-   * 
+   *
    * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select course names that are offered in both departments A and B
    * await db.select({ courseName: depA.courseName })
@@ -336,7 +336,7 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
    *   );
    * // or
    * import { intersect } from 'drizzle-orm/sqlite-core'
-   * 
+   *
    * await intersect(
    *   db.select({ courseName: depA.courseName }).from(depA),
    *   db.select({ courseName: depB.courseName }).from(depB)
@@ -346,13 +346,13 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   intersect = this.createSetOperator("intersect", false);
   /**
    * Adds `except` set operator to the query.
-   * 
+   *
    * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all courses offered in department A but not in department B
    * await db.select({ courseName: depA.courseName })
@@ -362,7 +362,7 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
    *   );
    * // or
    * import { except } from 'drizzle-orm/sqlite-core'
-   * 
+   *
    * await except(
    *   db.select({ courseName: depA.courseName }).from(depA),
    *   db.select({ courseName: depB.courseName }).from(depB)
@@ -375,35 +375,35 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
     this.config.setOperators.push(...setOperators);
     return this;
   }
-  /** 
+  /**
    * Adds a `where` clause to the query.
-   * 
+   *
    * Calling this method will select only those rows that fulfill a specified condition.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
-   * 
+   *
    * @param where the `where` clause.
-   * 
+   *
    * @example
    * You can use conditional operators and `sql function` to filter the rows to be selected.
-   * 
+   *
    * ```ts
    * // Select all cars with green color
    * await db.select().from(cars).where(eq(cars.color, 'green'));
    * // or
    * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
    * ```
-   * 
+   *
    * You can logically combine conditional operators with `and()` and `or()` operators:
-   * 
+   *
    * ```ts
    * // Select all BMW cars with a green color
    * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
-   * 
+   *
    * // Select all cars with the green or blue color
    * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
    * ```
-  */
+   */
   where(where) {
     if (typeof where === "function") {
       where = where(
@@ -418,15 +418,15 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   }
   /**
    * Adds a `having` clause to the query.
-   * 
+   *
    * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
-   * 
+   *
    * @param having the `having` clause.
-   * 
+   *
    * @example
-   * 
+   *
    * ```ts
    * // Select all brands with more than one car
    * await db.select({
@@ -490,13 +490,13 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   }
   /**
    * Adds a `limit` clause to the query.
-   * 
+   *
    * Calling this method will set the maximum number of rows that will be returned by this query.
    *
    * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
-   * 
+   *
    * @param limit the `limit` clause.
-   * 
+   *
    * @example
    *
    * ```ts
@@ -514,13 +514,13 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
   }
   /**
    * Adds an `offset` clause to the query.
-   * 
+   *
    * Calling this method will skip a number of rows when returning results from this query.
-   * 
+   *
    * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
-   * 
+   *
    * @param offset the `offset` clause.
-   * 
+   *
    * @example
    *
    * ```ts
@@ -563,7 +563,8 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
 }
 class SQLiteSelectBase extends SQLiteSelectQueryBuilderBase {
   static [entityKind] = "SQLiteSelect";
-  prepare(isOneTimeQuery) {
+  /** @internal */
+  _prepare(isOneTimeQuery = true) {
     if (!this.session) {
       throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
     }
@@ -576,17 +577,20 @@ class SQLiteSelectBase extends SQLiteSelectQueryBuilderBase {
     query.joinsNotNullableMap = this.joinsNotNullableMap;
     return query;
   }
+  prepare() {
+    return this._prepare(false);
+  }
   run = (placeholderValues) => {
-    return this.prepare(true).run(placeholderValues);
+    return this._prepare().run(placeholderValues);
   };
   all = (placeholderValues) => {
-    return this.prepare(true).all(placeholderValues);
+    return this._prepare().all(placeholderValues);
   };
   get = (placeholderValues) => {
-    return this.prepare(true).get(placeholderValues);
+    return this._prepare().get(placeholderValues);
   };
   values = (placeholderValues) => {
-    return this.prepare(true).values(placeholderValues);
+    return this._prepare().values(placeholderValues);
   };
   async execute() {
     return this.all();