@erfanium/drizzle-orm 1.0.0 → 1.0.1

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

@@ -1,642 +1,630 @@
-import { MySqlViewBase } from "../view-base.js";
-import { UniqueConstraintBuilder } from "../unique-constraint.js";
-import { IndexBuilder } from "../indexes.js";
-import { AnyMySqlSelectQueryBuilder, GetMySqlSetOperators, LockConfig, LockStrength, MySqlCreateSetOperatorFn, MySqlCrossJoinFn, MySqlJoinFn, MySqlSelectConfig, MySqlSelectDynamic, MySqlSelectHKTBase, MySqlSelectKind, MySqlSelectQueryBuilderHKT, MySqlSelectWithout, MySqlSetOperatorExcludedMethods, MySqlSetOperatorWithResult, SelectedFields, SetOperatorRightSelect } from "./select.types.js";
-import { entityKind } from "../../entity.js";
-import { ValueOrArray } from "../../utils.js";
-import { ColumnsSelection, CommentInput, Placeholder, Query, SQL } from "../../sql/sql.js";
-import { Subquery } from "../../subquery.js";
-import { TypedQueryBuilder } from "../../query-builders/query-builder.js";
-import { MySqlDialect } from "../dialect.js";
-import { MySqlTable } from "../table.js";
-import { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from "../../query-builders/select.types.js";
-import { MySqlColumn } from "../columns/index.js";
-import { SubqueryWithSelection } from "../subquery.js";
-import { CacheConfig, WithCacheConfig } from "../../cache/core/types.js";
-import { MySqlSession } from "../session.js";
-
-//#region src/mysql-core/query-builders/select.d.ts
-type IndexForHint = IndexBuilder | UniqueConstraintBuilder<string> | string;
-type IndexConfig = {
-  useIndex?: IndexForHint | IndexForHint[];
-  forceIndex?: IndexForHint | IndexForHint[];
-  ignoreIndex?: IndexForHint | IndexForHint[];
+import type { CacheConfig, WithCacheConfig } from '../../cache/core/types.js';
+import { entityKind } from '../../entity.js';
+import type { MySqlColumn } from '../columns/index.js';
+import type { MySqlDialect } from '../dialect.js';
+import type { MySqlSession } from '../session.js';
+import type { SubqueryWithSelection } from '../subquery.js';
+import { MySqlTable } from '../table.js';
+import { TypedQueryBuilder } from '../../query-builders/query-builder.js';
+import type { BuildSubquerySelection, GetSelectTableName, GetSelectTableSelection, JoinNullability, SelectMode, SelectResult } from '../../query-builders/select.types.js';
+import type { ColumnsSelection, CommentInput, Placeholder, Query } from '../../sql/sql.js';
+import { SQL } from '../../sql/sql.js';
+import { Subquery } from '../../subquery.js';
+import type { ValueOrArray } from '../../utils.js';
+import type { IndexBuilder } from '../indexes.js';
+import type { UniqueConstraintBuilder } from '../unique-constraint.js';
+import { MySqlViewBase } from '../view-base.js';
+import type { AnyMySqlSelectQueryBuilder, GetMySqlSetOperators, LockConfig, LockStrength, MySqlCreateSetOperatorFn, MySqlCrossJoinFn, MySqlJoinFn, MySqlSelectConfig, MySqlSelectDynamic, MySqlSelectHKTBase, MySqlSelectKind, MySqlSelectQueryBuilderHKT, MySqlSelectWithout, MySqlSetOperatorExcludedMethods, MySqlSetOperatorWithResult, SelectedFields, SetOperatorRightSelect } from './select.types.js';
+export type IndexForHint = IndexBuilder | UniqueConstraintBuilder<string> | string;
+export type IndexConfig = {
+    useIndex?: IndexForHint | IndexForHint[];
+    forceIndex?: IndexForHint | IndexForHint[];
+    ignoreIndex?: IndexForHint | IndexForHint[];
 };
-interface MySqlSelectBuilderConstructor {
-  new (config: {
-    table: MySqlSelectConfig['table'];
-    fields: MySqlSelectConfig['fields'];
-    isPartialSelect: boolean;
-    session: MySqlSession | undefined;
-    dialect: MySqlDialect;
-    withList: Subquery[];
-    distinct: boolean | undefined;
-    useIndex?: string[];
-    forceIndex?: string[];
-    ignoreIndex?: string[];
-  }): AnyMySqlSelectQueryBuilder;
+export interface MySqlSelectBuilderConstructor {
+    new (config: {
+        table: MySqlSelectConfig['table'];
+        fields: MySqlSelectConfig['fields'];
+        isPartialSelect: boolean;
+        session: MySqlSession | undefined;
+        dialect: MySqlDialect;
+        withList: Subquery[];
+        distinct: boolean | undefined;
+        useIndex?: string[];
+        forceIndex?: string[];
+        ignoreIndex?: string[];
+    }): AnyMySqlSelectQueryBuilder;
 }
-declare class MySqlSelectBuilder<TSelection extends SelectedFields | undefined, THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT> {
-  private builder;
-  static readonly [entityKind]: string;
-  private fields;
-  private session;
-  private dialect;
-  private withList;
-  private distinct;
-  constructor(config: {
-    fields: TSelection;
-    session: MySqlSession | undefined;
-    dialect: MySqlDialect;
-    withList?: Subquery[];
-    distinct?: boolean;
-  }, builder?: MySqlSelectBuilderConstructor);
-  from<TFrom extends MySqlTable | Subquery | MySqlViewBase | SQL>(source: TFrom, onIndex?: TFrom extends MySqlTable ? IndexConfig : 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views'): MySqlSelectKind<THKT, GetSelectTableName<TFrom>, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial', GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, 'not-null'> : {}, false, never>;
+export declare class MySqlSelectBuilder<TSelection extends SelectedFields | undefined, THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT> {
+    private builder;
+    static readonly [entityKind]: string;
+    private fields;
+    private session;
+    private dialect;
+    private withList;
+    private distinct;
+    constructor(config: {
+        fields: TSelection;
+        session: MySqlSession | undefined;
+        dialect: MySqlDialect;
+        withList?: Subquery[];
+        distinct?: boolean;
+    }, builder?: MySqlSelectBuilderConstructor);
+    from<TFrom extends MySqlTable | Subquery | MySqlViewBase | SQL>(source: TFrom, onIndex?: TFrom extends MySqlTable ? IndexConfig : 'Index hint configuration is allowed only for MySqlTable and not for subqueries or views'): MySqlSelectKind<THKT, GetSelectTableName<TFrom>, TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection, TSelection extends undefined ? 'single' : 'partial', GetSelectTableName<TFrom> extends string ? Record<GetSelectTableName<TFrom>, 'not-null'> : {}, false, never>;
 }
-type MySqlSelect<TTableName extends string | undefined = string | undefined, TSelection extends ColumnsSelection = Record<string, any>, TSelectMode extends SelectMode = SelectMode, TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>> = MySqlSelectBase<MySqlSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
-declare class MySqlSelectBase<THKT extends MySqlSelectHKTBase, TTableName extends string | undefined, 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 _: {
-    readonly hkt: THKT;
-    readonly tableName: TTableName;
-    readonly selection: TSelection;
-    readonly selectMode: TSelectMode;
-    readonly nullabilityMap: TNullabilityMap;
-    readonly dynamic: TDynamic;
-    readonly excludedMethods: TExcludedMethods;
-    readonly result: TResult;
-    readonly selectedFields: TSelectedFields;
-    readonly config: MySqlSelectConfig;
-  };
-  protected config: MySqlSelectConfig;
-  protected joinsNotNullableMap: Record<string, boolean>;
-  private tableName;
-  private isPartialSelect;
-  protected dialect: MySqlDialect;
-  protected cacheConfig?: WithCacheConfig;
-  protected usedTables: Set<string>;
-  constructor({
-    table,
-    fields,
-    isPartialSelect,
-    session,
-    dialect,
-    withList,
-    distinct,
-    useIndex,
-    forceIndex,
-    ignoreIndex
-  }: {
-    table: MySqlSelectConfig['table'];
-    fields: MySqlSelectConfig['fields'];
-    isPartialSelect: boolean;
-    session: MySqlSession | undefined;
-    dialect: MySqlDialect;
-    withList: Subquery[];
-    distinct: boolean | undefined;
-    useIndex?: string[];
-    forceIndex?: string[];
-    ignoreIndex?: string[];
-  });
-  private createJoin;
-  /**
-   * 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.
-   * @param onIndex index hint.
-   *
-   * @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,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .leftJoin(pets, eq(users.id, pets.ownerId))
-   *
-   * // Select userId and petId with use index hint
-   * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
-   *   userId: users.id,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .leftJoin(pets, eq(users.id, pets.ownerId), {
-   *     useIndex: ['pets_owner_id_index']
-   * })
-   * ```
-   */
-  leftJoin: MySqlJoinFn<this, TDynamic, "left", false>;
-  /**
-   * Executes a `left join lateral` operation by adding subquery to the current query.
-   *
-   * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
-   *
-   * 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-lateral}
-   *
-   * @param table the subquery to join.
-   * @param on the `on` clause.
-   */
-  leftJoinLateral: MySqlJoinFn<this, TDynamic, "left", true>;
-  /**
-   * 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.
-   * @param onIndex index hint.
-   *
-   * @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,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .rightJoin(pets, eq(users.id, pets.ownerId))
-   *
-   * // Select userId and petId with use index hint
-   * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
-   *   userId: users.id,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .leftJoin(pets, eq(users.id, pets.ownerId), {
-   *     useIndex: ['pets_owner_id_index']
-   * })
-   * ```
-   */
-  rightJoin: MySqlJoinFn<this, TDynamic, "right", false>;
-  /**
-   * 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.
-   * @param onIndex index hint.
-   *
-   * @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,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .innerJoin(pets, eq(users.id, pets.ownerId))
-   *
-   * // Select userId and petId with use index hint
-   * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
-   *   userId: users.id,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .leftJoin(pets, eq(users.id, pets.ownerId), {
-   *     useIndex: ['pets_owner_id_index']
-   * })
-   * ```
-   */
-  innerJoin: MySqlJoinFn<this, TDynamic, "inner", false>;
-  /**
-   * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
-   *
-   * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
-   *
-   * 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-lateral}
-   *
-   * @param table the subquery to join.
-   * @param on the `on` clause.
-   */
-  innerJoinLateral: MySqlJoinFn<this, TDynamic, "inner", true>;
-  /**
-   * Executes a `cross 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 all rows from each table.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
-   *
-   * @param table the table to join.
-   * @param onIndex index hint.
-   *
-   * @example
-   *
-   * ```ts
-   * // Select all users, each user with every pet
-   * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
-   *   .from(users)
-   *   .crossJoin(pets)
-   *
-   * // Select userId and petId
-   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
-   *   userId: users.id,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .crossJoin(pets)
-   *
-   * // Select userId and petId with use index hint
-   * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
-   *   userId: users.id,
-   *   petId: pets.id,
-   * })
-   *   .from(users)
-   *   .crossJoin(pets, {
-   *     useIndex: ['pets_owner_id_index']
-   * })
-   * ```
-   */
-  crossJoin: MySqlCrossJoinFn<this, TDynamic, false>;
-  /**
-   * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
-   *
-   * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
-   *
-   * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
-   *
-   * @param table the query to join.
-   */
-  crossJoinLateral: MySqlCrossJoinFn<this, TDynamic, true>;
-  private createSetOperator;
-  /**
-   * 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 })
-   *   .from(users)
-   *   .union(
-   *     db.select({ name: customers.name }).from(customers)
-   *   );
-   * // or
-   * import { union } from 'drizzle-orm/mysql-core'
-   *
-   * await union(
-   *   db.select({ name: users.name }).from(users),
-   *   db.select({ name: customers.name }).from(customers)
-   * );
-   * ```
-   */
-  union: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
-  /**
-   * 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 })
-   *   .from(onlineSales)
-   *   .unionAll(
-   *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
-   *   );
-   * // or
-   * import { unionAll } from 'drizzle-orm/mysql-core'
-   *
-   * await unionAll(
-   *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
-   *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
-   * );
-   * ```
-   */
-  unionAll: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, 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 })
-   *   .from(depA)
-   *   .intersect(
-   *     db.select({ courseName: depB.courseName }).from(depB)
-   *   );
-   * // or
-   * import { intersect } from 'drizzle-orm/mysql-core'
-   *
-   * await intersect(
-   *   db.select({ courseName: depA.courseName }).from(depA),
-   *   db.select({ courseName: depB.courseName }).from(depB)
-   * );
-   * ```
-   */
-  intersect: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
-  /**
-   * Adds `intersect all` set operator to the query.
-   *
-   * Calling this method will retain only the rows that are present in both result sets including all duplicates.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
-   *
-   * @example
-   *
-   * ```ts
-   * // Select all products and quantities that are ordered by both regular and VIP customers
-   * await db.select({
-   *   productId: regularCustomerOrders.productId,
-   *   quantityOrdered: regularCustomerOrders.quantityOrdered
-   * })
-   * .from(regularCustomerOrders)
-   * .intersectAll(
-   *   db.select({
-   *     productId: vipCustomerOrders.productId,
-   *     quantityOrdered: vipCustomerOrders.quantityOrdered
-   *   })
-   *   .from(vipCustomerOrders)
-   * );
-   * // or
-   * import { intersectAll } from 'drizzle-orm/mysql-core'
-   *
-   * await intersectAll(
-   *   db.select({
-   *     productId: regularCustomerOrders.productId,
-   *     quantityOrdered: regularCustomerOrders.quantityOrdered
-   *   })
-   *   .from(regularCustomerOrders),
-   *   db.select({
-   *     productId: vipCustomerOrders.productId,
-   *     quantityOrdered: vipCustomerOrders.quantityOrdered
-   *   })
-   *   .from(vipCustomerOrders)
-   * );
-   * ```
-   */
-  intersectAll: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
-  /**
-   * 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 })
-   *   .from(depA)
-   *   .except(
-   *     db.select({ courseName: depB.courseName }).from(depB)
-   *   );
-   * // or
-   * import { except } from 'drizzle-orm/mysql-core'
-   *
-   * await except(
-   *   db.select({ courseName: depA.courseName }).from(depA),
-   *   db.select({ courseName: depB.courseName }).from(depB)
-   * );
-   * ```
-   */
-  except: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
-  /**
-   * Adds `except all` set operator to the query.
-   *
-   * Calling this method will retrieve all 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-all}
-   *
-   * @example
-   *
-   * ```ts
-   * // Select all products that are ordered by regular customers but not by VIP customers
-   * await db.select({
-   *   productId: regularCustomerOrders.productId,
-   *   quantityOrdered: regularCustomerOrders.quantityOrdered,
-   * })
-   * .from(regularCustomerOrders)
-   * .exceptAll(
-   *   db.select({
-   *     productId: vipCustomerOrders.productId,
-   *     quantityOrdered: vipCustomerOrders.quantityOrdered,
-   *   })
-   *   .from(vipCustomerOrders)
-   * );
-   * // or
-   * import { exceptAll } from 'drizzle-orm/mysql-core'
-   *
-   * await exceptAll(
-   *   db.select({
-   *     productId: regularCustomerOrders.productId,
-   *     quantityOrdered: regularCustomerOrders.quantityOrdered
-   *   })
-   *   .from(regularCustomerOrders),
-   *   db.select({
-   *     productId: vipCustomerOrders.productId,
-   *     quantityOrdered: vipCustomerOrders.quantityOrdered
-   *   })
-   *   .from(vipCustomerOrders)
-   * );
-   * ```
-   */
-  exceptAll: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
-  /**
-   * 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: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined): MySqlSelectWithout<this, TDynamic, 'where'>;
-  /**
-   * 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({
-   * 	brand: cars.brand,
-   * 	count: sql<number>`cast(count(${cars.id}) as int)`,
-   * })
-   *   .from(cars)
-   *   .groupBy(cars.brand)
-   *   .having(({ count }) => gt(count, 1));
-   * ```
-   */
-  having(having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined): MySqlSelectWithout<this, TDynamic, 'having'>;
-  /**
-   * Adds a `group by` clause to the query.
-   *
-   * Calling this method will group rows that have the same values into summary rows, often used for aggregation purposes.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
-   *
-   * @example
-   *
-   * ```ts
-   * // Group and count people by their last names
-   * await db.select({
-   *    lastName: people.lastName,
-   *    count: sql<number>`cast(count(*) as int)`
-   * })
-   *   .from(people)
-   *   .groupBy(people.lastName);
-   * ```
-   */
-  groupBy(builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
-  groupBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
-  /**
-   * Adds an `order by` clause to the query.
-   *
-   * Calling this method will sort the result-set in ascending or descending order. By default, the sort order is ascending.
-   *
-   * See docs: {@link https://orm.drizzle.team/docs/select#order-by}
-   *
-   * @example
-   *
-   * ```
-   * // Select cars ordered by year
-   * await db.select().from(cars).orderBy(cars.year);
-   * ```
-   *
-   * You can specify whether results are in ascending or descending order with the `asc()` and `desc()` operators.
-   *
-   * ```ts
-   * // Select cars ordered by year in descending order
-   * await db.select().from(cars).orderBy(desc(cars.year));
-   *
-   * // Select cars ordered by year and price
-   * await db.select().from(cars).orderBy(asc(cars.year), desc(cars.price));
-   * ```
-   */
-  orderBy(builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
-  orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
-  /**
-   * 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
-   * // Get the first 10 people from this query.
-   * await db.select().from(people).limit(10);
-   * ```
-   */
-  limit(limit: number | Placeholder): MySqlSelectWithout<this, TDynamic, 'limit'>;
-  /**
-   * 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
-   * // Get the 10th-20th people from this query.
-   * await db.select().from(people).offset(10).limit(10);
-   * ```
-   */
-  offset(offset: number | Placeholder): MySqlSelectWithout<this, TDynamic, 'offset'>;
-  /**
-   * Adds a `for` clause to the query.
-   *
-   * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
-   *
-   * See docs: {@link https://dev.mysql.com/doc/refman/8.0/en/innodb-locking-reads.html}
-   *
-   * @param strength the lock strength.
-   * @param config the lock configuration.
-   */
-  for(strength: LockStrength, config?: LockConfig): MySqlSelectWithout<this, TDynamic, 'for'>;
-  /**
-   * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
-   */
-  comment(comment: CommentInput): MySqlSelectWithout<this, TDynamic, 'comment'>;
-  getSQL(): SQL;
-  toSQL(): Query;
-  as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
-  $dynamic(): MySqlSelectDynamic<this>;
-  $withCache(config?: {
-    config?: CacheConfig;
-    tag?: string;
-    autoInvalidate?: boolean;
-  } | false): this;
+export type MySqlSelect<TTableName extends string | undefined = string | undefined, TSelection extends ColumnsSelection = Record<string, any>, TSelectMode extends SelectMode = SelectMode, TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>> = MySqlSelectBase<MySqlSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode, TNullabilityMap, true, never>;
+export declare class MySqlSelectBase<THKT extends MySqlSelectHKTBase, TTableName extends string | undefined, 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 _: {
+        readonly hkt: THKT;
+        readonly tableName: TTableName;
+        readonly selection: TSelection;
+        readonly selectMode: TSelectMode;
+        readonly nullabilityMap: TNullabilityMap;
+        readonly dynamic: TDynamic;
+        readonly excludedMethods: TExcludedMethods;
+        readonly result: TResult;
+        readonly selectedFields: TSelectedFields;
+        readonly config: MySqlSelectConfig;
+    };
+    protected config: MySqlSelectConfig;
+    protected joinsNotNullableMap: Record<string, boolean>;
+    private tableName;
+    private isPartialSelect;
+    protected dialect: MySqlDialect;
+    protected cacheConfig?: WithCacheConfig;
+    protected usedTables: Set<string>;
+    constructor({ table, fields, isPartialSelect, session, dialect, withList, distinct, useIndex, forceIndex, ignoreIndex }: {
+        table: MySqlSelectConfig['table'];
+        fields: MySqlSelectConfig['fields'];
+        isPartialSelect: boolean;
+        session: MySqlSession | undefined;
+        dialect: MySqlDialect;
+        withList: Subquery[];
+        distinct: boolean | undefined;
+        useIndex?: string[];
+        forceIndex?: string[];
+        ignoreIndex?: string[];
+    });
+    private createJoin;
+    /**
+     * 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.
+     * @param onIndex index hint.
+     *
+     * @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,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .leftJoin(pets, eq(users.id, pets.ownerId))
+     *
+     * // Select userId and petId with use index hint
+     * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
+     *   userId: users.id,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .leftJoin(pets, eq(users.id, pets.ownerId), {
+     *     useIndex: ['pets_owner_id_index']
+     * })
+     * ```
+     */
+    leftJoin: MySqlJoinFn<this, TDynamic, "left", false>;
+    /**
+     * Executes a `left join lateral` operation by adding subquery to the current query.
+     *
+     * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
+     *
+     * 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-lateral}
+     *
+     * @param table the subquery to join.
+     * @param on the `on` clause.
+     */
+    leftJoinLateral: MySqlJoinFn<this, TDynamic, "left", true>;
+    /**
+     * 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.
+     * @param onIndex index hint.
+     *
+     * @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,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .rightJoin(pets, eq(users.id, pets.ownerId))
+     *
+     * // Select userId and petId with use index hint
+     * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
+     *   userId: users.id,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .leftJoin(pets, eq(users.id, pets.ownerId), {
+     *     useIndex: ['pets_owner_id_index']
+     * })
+     * ```
+     */
+    rightJoin: MySqlJoinFn<this, TDynamic, "right", false>;
+    /**
+     * 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.
+     * @param onIndex index hint.
+     *
+     * @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,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .innerJoin(pets, eq(users.id, pets.ownerId))
+     *
+     * // Select userId and petId with use index hint
+     * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
+     *   userId: users.id,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .leftJoin(pets, eq(users.id, pets.ownerId), {
+     *     useIndex: ['pets_owner_id_index']
+     * })
+     * ```
+     */
+    innerJoin: MySqlJoinFn<this, TDynamic, "inner", false>;
+    /**
+     * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
+     *
+     * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
+     *
+     * 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-lateral}
+     *
+     * @param table the subquery to join.
+     * @param on the `on` clause.
+     */
+    innerJoinLateral: MySqlJoinFn<this, TDynamic, "inner", true>;
+    /**
+     * Executes a `cross 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 all rows from each table.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
+     *
+     * @param table the table to join.
+     * @param onIndex index hint.
+     *
+     * @example
+     *
+     * ```ts
+     * // Select all users, each user with every pet
+     * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
+     *   .from(users)
+     *   .crossJoin(pets)
+     *
+     * // Select userId and petId
+     * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+     *   userId: users.id,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .crossJoin(pets)
+     *
+     * // Select userId and petId with use index hint
+     * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
+     *   userId: users.id,
+     *   petId: pets.id,
+     * })
+     *   .from(users)
+     *   .crossJoin(pets, {
+     *     useIndex: ['pets_owner_id_index']
+     * })
+     * ```
+     */
+    crossJoin: MySqlCrossJoinFn<this, TDynamic, false>;
+    /**
+     * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
+     *
+     * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
+     *
+     * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
+     *
+     * @param table the query to join.
+     */
+    crossJoinLateral: MySqlCrossJoinFn<this, TDynamic, true>;
+    private createSetOperator;
+    /**
+     * 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 })
+     *   .from(users)
+     *   .union(
+     *     db.select({ name: customers.name }).from(customers)
+     *   );
+     * // or
+     * import { union } from 'drizzle-orm/mysql-core'
+     *
+     * await union(
+     *   db.select({ name: users.name }).from(users),
+     *   db.select({ name: customers.name }).from(customers)
+     * );
+     * ```
+     */
+    union: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
+    /**
+     * 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 })
+     *   .from(onlineSales)
+     *   .unionAll(
+     *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+     *   );
+     * // or
+     * import { unionAll } from 'drizzle-orm/mysql-core'
+     *
+     * await unionAll(
+     *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
+     *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
+     * );
+     * ```
+     */
+    unionAll: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, 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 })
+     *   .from(depA)
+     *   .intersect(
+     *     db.select({ courseName: depB.courseName }).from(depB)
+     *   );
+     * // or
+     * import { intersect } from 'drizzle-orm/mysql-core'
+     *
+     * await intersect(
+     *   db.select({ courseName: depA.courseName }).from(depA),
+     *   db.select({ courseName: depB.courseName }).from(depB)
+     * );
+     * ```
+     */
+    intersect: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
+    /**
+     * Adds `intersect all` set operator to the query.
+     *
+     * Calling this method will retain only the rows that are present in both result sets including all duplicates.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
+     *
+     * @example
+     *
+     * ```ts
+     * // Select all products and quantities that are ordered by both regular and VIP customers
+     * await db.select({
+     *   productId: regularCustomerOrders.productId,
+     *   quantityOrdered: regularCustomerOrders.quantityOrdered
+     * })
+     * .from(regularCustomerOrders)
+     * .intersectAll(
+     *   db.select({
+     *     productId: vipCustomerOrders.productId,
+     *     quantityOrdered: vipCustomerOrders.quantityOrdered
+     *   })
+     *   .from(vipCustomerOrders)
+     * );
+     * // or
+     * import { intersectAll } from 'drizzle-orm/mysql-core'
+     *
+     * await intersectAll(
+     *   db.select({
+     *     productId: regularCustomerOrders.productId,
+     *     quantityOrdered: regularCustomerOrders.quantityOrdered
+     *   })
+     *   .from(regularCustomerOrders),
+     *   db.select({
+     *     productId: vipCustomerOrders.productId,
+     *     quantityOrdered: vipCustomerOrders.quantityOrdered
+     *   })
+     *   .from(vipCustomerOrders)
+     * );
+     * ```
+     */
+    intersectAll: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
+    /**
+     * 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 })
+     *   .from(depA)
+     *   .except(
+     *     db.select({ courseName: depB.courseName }).from(depB)
+     *   );
+     * // or
+     * import { except } from 'drizzle-orm/mysql-core'
+     *
+     * await except(
+     *   db.select({ courseName: depA.courseName }).from(depA),
+     *   db.select({ courseName: depB.courseName }).from(depB)
+     * );
+     * ```
+     */
+    except: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
+    /**
+     * Adds `except all` set operator to the query.
+     *
+     * Calling this method will retrieve all 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-all}
+     *
+     * @example
+     *
+     * ```ts
+     * // Select all products that are ordered by regular customers but not by VIP customers
+     * await db.select({
+     *   productId: regularCustomerOrders.productId,
+     *   quantityOrdered: regularCustomerOrders.quantityOrdered,
+     * })
+     * .from(regularCustomerOrders)
+     * .exceptAll(
+     *   db.select({
+     *     productId: vipCustomerOrders.productId,
+     *     quantityOrdered: vipCustomerOrders.quantityOrdered,
+     *   })
+     *   .from(vipCustomerOrders)
+     * );
+     * // or
+     * import { exceptAll } from 'drizzle-orm/mysql-core'
+     *
+     * await exceptAll(
+     *   db.select({
+     *     productId: regularCustomerOrders.productId,
+     *     quantityOrdered: regularCustomerOrders.quantityOrdered
+     *   })
+     *   .from(regularCustomerOrders),
+     *   db.select({
+     *     productId: vipCustomerOrders.productId,
+     *     quantityOrdered: vipCustomerOrders.quantityOrdered
+     *   })
+     *   .from(vipCustomerOrders)
+     * );
+     * ```
+     */
+    exceptAll: <TValue extends MySqlSetOperatorWithResult<TResult>>(rightSelection: ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>) | SetOperatorRightSelect<TValue, TResult>) => MySqlSelectWithout<this, TDynamic, MySqlSetOperatorExcludedMethods, true>;
+    /**
+     * 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: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined): MySqlSelectWithout<this, TDynamic, 'where'>;
+    /**
+     * 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({
+     * 	brand: cars.brand,
+     * 	count: sql<number>`cast(count(${cars.id}) as int)`,
+     * })
+     *   .from(cars)
+     *   .groupBy(cars.brand)
+     *   .having(({ count }) => gt(count, 1));
+     * ```
+     */
+    having(having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined): MySqlSelectWithout<this, TDynamic, 'having'>;
+    /**
+     * Adds a `group by` clause to the query.
+     *
+     * Calling this method will group rows that have the same values into summary rows, often used for aggregation purposes.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
+     *
+     * @example
+     *
+     * ```ts
+     * // Group and count people by their last names
+     * await db.select({
+     *    lastName: people.lastName,
+     *    count: sql<number>`cast(count(*) as int)`
+     * })
+     *   .from(people)
+     *   .groupBy(people.lastName);
+     * ```
+     */
+    groupBy(builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
+    groupBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
+    /**
+     * Adds an `order by` clause to the query.
+     *
+     * Calling this method will sort the result-set in ascending or descending order. By default, the sort order is ascending.
+     *
+     * See docs: {@link https://orm.drizzle.team/docs/select#order-by}
+     *
+     * @example
+     *
+     * ```
+     * // Select cars ordered by year
+     * await db.select().from(cars).orderBy(cars.year);
+     * ```
+     *
+     * You can specify whether results are in ascending or descending order with the `asc()` and `desc()` operators.
+     *
+     * ```ts
+     * // Select cars ordered by year in descending order
+     * await db.select().from(cars).orderBy(desc(cars.year));
+     *
+     * // Select cars ordered by year and price
+     * await db.select().from(cars).orderBy(asc(cars.year), desc(cars.price));
+     * ```
+     */
+    orderBy(builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
+    orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
+    /**
+     * 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
+     * // Get the first 10 people from this query.
+     * await db.select().from(people).limit(10);
+     * ```
+     */
+    limit(limit: number | Placeholder): MySqlSelectWithout<this, TDynamic, 'limit'>;
+    /**
+     * 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
+     * // Get the 10th-20th people from this query.
+     * await db.select().from(people).offset(10).limit(10);
+     * ```
+     */
+    offset(offset: number | Placeholder): MySqlSelectWithout<this, TDynamic, 'offset'>;
+    /**
+     * Adds a `for` clause to the query.
+     *
+     * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
+     *
+     * See docs: {@link https://dev.mysql.com/doc/refman/8.0/en/innodb-locking-reads.html}
+     *
+     * @param strength the lock strength.
+     * @param config the lock configuration.
+     */
+    for(strength: LockStrength, config?: LockConfig): MySqlSelectWithout<this, TDynamic, 'for'>;
+    /**
+     * Attach [sqlcommenter](https://google.github.io/sqlcommenter) comment to a query
+     */
+    comment(comment: CommentInput): MySqlSelectWithout<this, TDynamic, 'comment'>;
+    getSQL(): SQL;
+    toSQL(): Query;
+    as<TAlias extends string>(alias: TAlias): SubqueryWithSelection<this['_']['selectedFields'], TAlias>;
+    $dynamic(): MySqlSelectDynamic<this>;
+    $withCache(config?: {
+        config?: CacheConfig;
+        tag?: string;
+        autoInvalidate?: boolean;
+    } | false): this;
 }
 /**
  * Adds `union` set operator to the query.
@@ -663,7 +651,7 @@ declare class MySqlSelectBase<THKT extends MySqlSelectHKTBase, TTableName extend
  *   );
  * ```
  */
-declare const union: MySqlCreateSetOperatorFn;
+export declare const union: MySqlCreateSetOperatorFn;
 /**
  * Adds `union all` set operator to the query.
  *
@@ -689,7 +677,7 @@ declare const union: MySqlCreateSetOperatorFn;
  *   );
  * ```
  */
-declare const unionAll: MySqlCreateSetOperatorFn;
+export declare const unionAll: MySqlCreateSetOperatorFn;
 /**
  * Adds `intersect` set operator to the query.
  *
@@ -715,7 +703,7 @@ declare const unionAll: MySqlCreateSetOperatorFn;
  *   );
  * ```
  */
-declare const intersect: MySqlCreateSetOperatorFn;
+export declare const intersect: MySqlCreateSetOperatorFn;
 /**
  * Adds `intersect all` set operator to the query.
  *
@@ -756,7 +744,7 @@ declare const intersect: MySqlCreateSetOperatorFn;
  * );
  * ```
  */
-declare const intersectAll: MySqlCreateSetOperatorFn;
+export declare const intersectAll: MySqlCreateSetOperatorFn;
 /**
  * Adds `except` set operator to the query.
  *
@@ -782,7 +770,7 @@ declare const intersectAll: MySqlCreateSetOperatorFn;
  *   );
  * ```
  */
-declare const except: MySqlCreateSetOperatorFn;
+export declare const except: MySqlCreateSetOperatorFn;
 /**
  * Adds `except all` set operator to the query.
  *
@@ -823,7 +811,4 @@ declare const except: MySqlCreateSetOperatorFn;
  * );
  * ```
  */
-declare const exceptAll: MySqlCreateSetOperatorFn;
-//#endregion
-export { IndexConfig, IndexForHint, MySqlSelect, MySqlSelectBase, MySqlSelectBuilder, MySqlSelectBuilderConstructor, except, exceptAll, intersect, intersectAll, union, unionAll };
-//# sourceMappingURL=select.d.ts.map
+export declare const exceptAll: MySqlCreateSetOperatorFn;