pqb 0.68.1 → 0.70.0

package/dist/index.d.ts

@@ -1776,6 +1776,8 @@ declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends Column {
   querySchema: ReturnType<Schema['boolean']>;
   private static _instance;
   static get instance(): BooleanColumn<DefaultSchemaConfig>;
+  private static _instanceSkipValueToArray;
+  static get instanceSkipValueToArray(): BooleanColumn<DefaultSchemaConfig>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
@@ -1959,21 +1961,23 @@ interface JoinItem {
   type: string;
   args: JoinItemArgs;
 }
-type getValueKey = typeof getValueKey;
-declare const getValueKey: unique symbol;
 interface PickQueryDataParsers {
   defaultParsers?: ColumnsParsers;
   parsers?: ColumnsParsers;
   batchParsers?: BatchParsers;
 }
 type ColumnParser = FnUnknownToUnknown;
+interface BatchParserPathEntry {
+  key: string;
+  returnType: QueryReturnType;
+}
 interface BatchParser {
-  path: string[];
-  fn: (path: string[], queryResult: {
+  path: BatchParserPathEntry[];
+  fn: (path: BatchParserPathEntry[], queryResult: {
     rows: unknown[];
   }) => MaybePromise<void>;
 }
-type ColumnsParsers = { [K in string | getValueKey]?: ColumnParser };
+type ColumnsParsers = { [K in string]?: ColumnParser };
 type BatchParsers = BatchParser[];
 interface QueryThen<T> {
   <TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
@@ -2105,12 +2109,6 @@ interface JoinCallback<T extends PickQuerySelectableShapeRelationsWithDataAs, Ar
   (q: JoinQueryBuilder<T, JoinArgToQuery<T, Arg>>): IsQuery;
 }
 type JoinCallbackArgs<T extends PickQuerySelectableShapeRelationsWithDataAs, Arg extends JoinFirstArg<T>> = [cb?: JoinCallback<T, Arg> | true];
-/**
- * Type of {@link QueryJoin.join} query method.
- */
-interface JoinQueryMethod {
-  <T extends PickQuerySelectableResultRelationsWithDataReturnTypeShapeAs, Arg extends JoinFirstArg<T>, Cb extends JoinCallbackArgs<T, Arg>>(this: T, arg: Arg, ...args: Cb | JoinArgs<T, Arg>): JoinResultFromArgs<T, Arg, Cb, true, true>;
-}
 declare class QueryJoin {
   /**
    * ## Select relation
@@ -2977,172 +2975,6 @@ interface AggregateOptions<T extends PickQuerySelectableResultRelationsWindows>
   over?: Over<T>;
 }
 type Over<T extends PickQuerySelectableResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
-interface ColumnsShape {
-  [K: string]: Column;
-}
-declare namespace ColumnsShape {
-  export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
-  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
-  export type Input<Shape extends Column.QueryColumnsInit, AppReadOnly = { [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never }[keyof Shape], Optional extends keyof Shape = { [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never }[keyof Shape]> = { [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['__inputType'] } & { [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['__inputType'] };
-  export type InputPartial<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
-  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
-  export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['__outputType'] };
-  export interface MapToObjectColumn<Shape extends Column.QueryColumns> {
-    dataType: 'object';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] };
-    __outputType: ShallowSimplify<ObjectOutput<Shape>>;
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
-    operators: OperatorsAny;
-  }
-  export interface MapToNullableObjectColumn<Shape extends Column.QueryColumns> {
-    dataType: 'object';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] };
-    __outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
-    operators: OperatorsAny;
-  }
-  export interface MapToPluckColumn<Shape extends Column.QueryColumns> {
-    dataType: 'array';
-    __type: Shape['pluck']['__type'][];
-    __outputType: Shape['pluck']['__outputType'][];
-    __queryType: Shape['pluck']['__queryType'][];
-    operators: OperatorsAny;
-  }
-  export interface MapToObjectArrayColumn<Shape extends Column.QueryColumns> {
-    dataType: 'array';
-    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
-    __outputType: ShallowSimplify<ObjectOutput<Shape>>[];
-    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
-    operators: OperatorsAny;
-  }
-  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
-  export {};
-}
-interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
-type SelectArgs<T extends SelectSelf> = ('*' | keyof T['__selectable'])[];
-interface SubQueryAddition<T extends PickQueryWithData> extends IsSubQuery {
-  withData: T['withData'];
-}
-type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? RelationQueryMaybeSingle<T['relations'][K]> & SubQueryAddition<T> : K extends keyof T ? T[K] : never };
-interface SelectAsArg<T extends SelectSelf> {
-  [K: string]: keyof T['__selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
-}
-type SelectAsFnReturnType = {
-  result: Column.QueryColumns;
-  returnType: Exclude<QueryReturnType, 'rows'>;
-} | Expression;
-interface SelectAsCheckReturnTypes {
-  [K: string]: PropertyKey | Expression | ((q: never) => SelectAsFnReturnType);
-}
-type SelectReturnType<T extends PickQueryReturnType> = T['returnType'] extends 'valueOrThrow' ? 'oneOrThrow' : T extends 'value' ? 'one' : T['returnType'] extends 'pluck' ? 'all' : T['returnType'];
-type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
-type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never }> : T[K] } : `Invalid return type of ${{ [K in keyof Obj]: Obj[K] extends ((...args: any[]) => any) ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never }[keyof Obj] & string}`;
-type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
-{ [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
-interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
-  result: Column.QueryColumns;
-  returnType: 'value' | 'valueOrThrow' | 'one' | 'oneOrThrow';
-}
-type SelectAsSelectable<Obj> = UnionToIntersection<{ [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? { [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
-  as: C;
-  column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
-} } : never }[keyof Obj]>;
-type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['__selectable'] ? T['__selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery | Expression) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
-type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape.MapToNullableObjectColumn<Arg['result']> : ColumnsShape.MapToObjectColumn<Arg['result']>;
-declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
-declare function _querySelect<T extends SelectSelf, Obj extends SelectAsArg<T>>(q: T, obj: Obj): SelectResultObj<T, Obj>;
-declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(q: T, args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
-declare class Select {
-  /**
-   * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
-   *
-   * The last argument can be an object. Keys of the object are column aliases, value can be a column name, sub-query, or raw SQL expression.
-   *
-   * ```ts
-   * import { sql } from './baseTable'
-   *
-   * // select columns of the table:
-   * db.table.select('id', 'name', { idAlias: 'id' });
-   *
-   * // accepts columns with table names:
-   * db.table.select('user.id', 'user.name', { nameAlias: 'user.name' });
-   *
-   * // table name may refer to the current table or a joined table:
-   * db.table
-   *   .join(db.message, 'authorId', 'user.id')
-   *   .select('user.name', 'message.text', { textAlias: 'message.text' });
-   *
-   * // select value from the sub-query,
-   * // this sub-query should return a single record and a single column:
-   * db.table.select({
-   *   subQueryResult: Otherdb.table.select('column').take(),
-   * });
-   *
-   * // select raw SQL value, specify the returning type via <generic> syntax:
-   * db.table.select({
-   *   raw: sql<number>`1 + 2`,
-   * });
-   *
-   * // select raw SQL value, the resulting type can be set by providing a column type in such way:
-   * db.table.select({
-   *   raw: sql`1 + 2`.type((t) => t.integer()),
-   * });
-   *
-   * // same raw SQL query as above, but the sql is returned from a callback
-   * db.table.select({
-   *   raw: () => sql`1 + 2`.type((t) => t.integer()),
-   * });
-   * ```
-   *
-   * When you use the ORM and defined relations, `select` can also accept callbacks with related table queries:
-   *
-   * ```ts
-   * await db.author.select({
-   *   allBooks: (q) => q.books,
-   *   firstBook: (q) => q.books.order({ createdAt: 'ASC' }).take(),
-   *   booksCount: (q) => q.books.count(),
-   * });
-   * ```
-   *
-   * When you're selecting a relation that's connected via `belongsTo` or `hasOne`, it becomes available to use in `order` or in `where`:
-   *
-   * ```ts
-   * // select books with their authors included, order by author name and filter by author column:
-   * await db.books
-   *   .select({
-   *     author: (q) => q.author,
-   *   })
-   *   .order('author.name')
-   *   .where({ 'author.isPopular': true });
-   * ```
-   */
-  select<T extends SelectSelf, Columns extends SelectArgs<T>>(this: T, ...args: Columns): SelectResult<T, Columns>;
-  select<T extends SelectSelf, Obj extends SelectAsArg<T>>(this: T, obj: Obj): SelectResultObj<T, Obj>;
-  select<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
-  /**
-   * When querying the table or creating records, all columns are selected by default,
-   * but updating and deleting queries are returning affected row counts by default.
-   *
-   * Use `selectAll` to select all columns. If the `.select` method was applied before it will be discarded.
-   *
-   * ```ts
-   * const selectFull = await db.table
-   *   .select('id', 'name') // discarded by `selectAll`
-   *   .selectAll();
-   *
-   * const updatedFull = await db.table.selectAll().where(conditions).update(data);
-   *
-   * const deletedFull = await db.table.selectAll().where(conditions).delete();
-   * ```
-   */
-  selectAll<T extends SelectSelf>(this: T): SelectResult<T, ['*']>;
-}
-interface QueryGetSelf extends PickQuerySelectable, PickQueryRelationsWithData {}
-type GetArg<T extends QueryGetSelf> = GetStringArg<T> | Expression | ((q: SelectAsFnArg<T>) => Expression | Query.Pick.SingleValueResult);
-type GetStringArg<T extends PickQuerySelectable> = keyof T['__selectable'] & string;
-type ResolveGetArgColumn<Arg> = Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => infer R) ? R extends Expression ? R['result']['value'] : R extends Query.Pick.SingleValueResult ? R['result']['value'] : never : never;
-type GetResult<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOrThrow<T, Arg> : SetQueryReturnsColumnOrThrow<T, ResolveGetArgColumn<Arg>>;
-type GetResultOptional<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOptional<T, Arg> : SetQueryReturnsColumnOptional<T, ResolveGetArgColumn<Arg>>;
 type HeadlineSearchArg<T extends PickQueryTsQuery> = Exclude<T['__tsQuery'], undefined>;
 interface HeadlineParams<T extends PickQuerySelectable> {
   text?: SelectableOrExpressionOfType<T, Column.Pick.QueryColumnOfType<string>>;
@@ -3479,16 +3311,6 @@ interface AggregateArgTypes {
 }
 interface AggregateMethods extends SearchAggregateMethods {}
 declare class AggregateMethods {
-  /**
-   * Use `exists()` to check if there is at least one record-matching condition.
-   *
-   * It will discard previous `select` statements if any. Returns a boolean.
-   *
-   * ```ts
-   * const exists: boolean = await db.table.where(...conditions).exists();
-   * ```
-   */
-  exists<T extends QueryGetSelf>(this: T): SetQueryReturnsColumnOrThrow<T, BooleanQueryColumn>;
   /**
    * Count records with the `count` function:
    *
@@ -5139,7 +4961,8 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
    */
   nestedCreateBatchMax: number;
 }
-type ShapeColumnPrimaryKeys<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never }[keyof Shape]]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> };
+type ShapeHasPrimaryKeys<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? K : never }[keyof Shape];
+type TablePrimaryKeys<Shape extends Column.QueryColumnsInit> = ShapeHasPrimaryKeys<Shape> extends never ? never : { [K in ShapeHasPrimaryKeys<Shape>]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> };
 type ShapeUniqueColumns<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? { [C in K]: UniqueQueryTypeOrExpression<Shape[K]['__queryType']> } : never }[keyof Shape];
 type UniqueConstraints<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]: Shape[K]['data']['primaryKey'] extends string ? string extends Shape[K]['data']['primaryKey'] ? never : Shape[K]['data']['primaryKey'] : Shape[K]['data']['unique'] extends string ? string extends Shape[K]['data']['unique'] ? never : Shape[K]['data']['unique'] : never }[keyof Shape];
 type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
@@ -5228,7 +5051,7 @@ type DbTableOptionScopes<Table extends string | undefined, Shape extends Column.
 interface QueryBuilder extends Query.NotReadOnlyQuery {
   returnType: undefined;
 }
-declare class Db<Table extends string | undefined = undefined, Shape extends Column.QueryColumnsInit = Column.QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends Column.QueryColumnsInit = Shape, Scopes extends RecordUnknown | undefined = EmptyObject, DefaultSelect extends keyof Shape = keyof Shape, ReadOnly extends true | undefined = undefined, Materialized extends true | undefined = undefined> extends QueryMethods<ColumnTypes> implements Query {
+declare class Db<Table extends string | undefined = undefined, Shape extends Column.QueryColumnsInit = Column.QueryColumnsInit, Data extends MaybeArray<TableDataItem> = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ReadOnly extends true | undefined = undefined, Options = never> extends QueryMethods<ColumnTypes> implements Query {
   adapterNotInTransaction: Adapter;
   qb: QueryBuilder;
   table: Table;
@@ -5236,19 +5059,21 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   q: QueryData;
   __isQuery: true;
   __as: Table & string;
-  __selectable: SelectableFromShape<ShapeWithComputed, Table>;
+  __selectable: SelectableFromShape<ComputedColumnsFromOptions<Shape, Options>, Table>;
   __readOnly: ReadOnly;
-  __materialized: Materialized;
+  __materialized: Options extends {
+    materialized: true;
+  } ? true : undefined;
   __hasSelect: boolean;
   __hasWhere: boolean;
   __defaults: { [K in { [K in keyof Shape]: unknown extends Shape[K]['data']['default'] ? never : K }[keyof Shape]]: true };
-  __scopes: { [K in keyof Scopes]: true };
-  __defaultSelect: DefaultSelect;
+  __scopes: { [K in keyof MapTableScopesOption<Options>]: true };
+  __defaultSelect: ColumnsShape.DefaultSelectKeys<Shape>;
   baseQuery: Query;
   columns: (keyof Shape)[];
   __outputType: ColumnsShape.DefaultSelectOutput<Shape>;
   __inputType: ColumnsShape.Input<Shape>;
-  result: { [K in DefaultSelect]: Shape[K] };
+  result: { [K in ColumnsShape.DefaultSelectKeys<Shape>]: Shape[K] };
   returnType: undefined;
   then: QueryThenShallowSimplifyArr<ColumnsShape.DefaultOutput<Shape>>;
   windows: EmptyObject;
@@ -5258,10 +5083,10 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   relationQueries: EmptyObject;
   withData: EmptyObject;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
-  internal: QueryInternal<{ [K in keyof PrimaryKeys]: (keyof PrimaryKeys extends K ? never : keyof PrimaryKeys) extends never ? PrimaryKeys[K] : never }[keyof PrimaryKeys], PrimaryKeys | UniqueColumns, { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? K : never }[keyof Shape] | keyof PrimaryKeys, UniqueColumnTuples, UniqueConstraints>;
+  internal: QueryInternal<TablePrimaryKeys<Shape> extends never ? never : { [K in keyof TablePrimaryKeys<Shape>]: (keyof TablePrimaryKeys<Shape> extends K ? never : keyof TablePrimaryKeys<Shape>) extends never ? TablePrimaryKeys<Shape>[K] : never }[keyof TablePrimaryKeys<Shape>], TablePrimaryKeys<Shape> | ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, { [K in keyof Shape]: Shape[K]['data']['unique'] extends string ? K : never }[keyof Shape] | keyof TablePrimaryKeys<Shape>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>>;
   catch: QueryCatch;
-  shape: ShapeWithComputed;
-  constructor(adapterNotInTransaction: Adapter, qb: QueryBuilder, table: Table | undefined, shape: ShapeWithComputed, columnTypes: ColumnTypes, asyncStorage: AsyncLocalStorage<AsyncState>, options: DbTableOptions<ColumnTypes, Table, ShapeWithComputed>, tableData?: TableData, viewData?: QueryInternal['viewData']);
+  shape: ComputedColumnsFromOptions<Shape, Options>;
+  constructor(adapterNotInTransaction: Adapter, qb: QueryBuilder, table: Table | undefined, shape: ComputedColumnsFromOptions<Shape, Options>, columnTypes: ColumnTypes, asyncStorage: AsyncLocalStorage<AsyncState>, options: DbTableOptions<ColumnTypes, Table, ComputedColumnsFromOptions<Shape, Options>>, tableData?: TableData, viewData?: QueryInternal['viewData']);
   /**
    * When in transaction, returns a db adapter object for the transaction,
    * returns a default adapter object otherwise.
@@ -5330,7 +5155,9 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   queryArrays<R extends any[] = any[]>(...args: SQLQueryArgs): Promise<QueryResult<R>>;
 }
 interface DbTableConstructor<ColumnTypes> {
-  <Table extends string, Shape extends Column.QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options): Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, ColumnTypes, Shape & ComputedColumnsFromOptions<Options['computed']>, MapTableScopesOption<Options>, ColumnsShape.DefaultSelectKeys<Shape>, Options['readOnly'] extends true ? true : undefined, Options['materialized'] extends true ? true : undefined>;
+  <Table extends string, Shape extends Column.QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape> | undefined>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options): Db<Table, Shape, Data, ColumnTypes, Options extends {
+    readOnly: true;
+  } ? true : undefined, Options>;
 }
 interface DbSqlMethod<ColumnTypes> {
   <T>(...args: StaticSQLArgs): RawSql<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
@@ -5348,7 +5175,7 @@ type MapTableScopesOption<T> = T extends {
 } ? {
   nonDeleted: unknown;
 } : EmptyObject;
-interface DbResult<ColumnTypes> extends Db<undefined, EmptyObject, never, never, never, never, ColumnTypes, never, never>, DbTableConstructor<ColumnTypes> {
+interface DbResult<ColumnTypes> extends Db<undefined, EmptyObject, never, ColumnTypes, never, never>, DbTableConstructor<ColumnTypes> {
   adapterNotInTransaction: Adapter;
   adapter: Adapter;
   close: Adapter['close'];
@@ -6071,6 +5898,7 @@ interface ExpressionData extends HasBeforeAndBeforeSet {
   expr?: Expression;
   before?: QueryBeforeHook[];
   dynamicBefore?: boolean;
+  getColumn?: Column;
 }
 declare abstract class Expression<T extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> {
   abstract result: {
@@ -6433,6 +6261,166 @@ declare class QueryTransaction {
    */
   recoverable<T>(this: T): T;
 }
+interface ColumnsShape {
+  [K: string]: Column;
+}
+declare namespace ColumnsShape {
+  export type DefaultSelectKeys<S extends Column.QueryColumnsInit> = { [K in keyof S]: S[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof S];
+  export type DefaultOutput<Set extends Column.QueryColumnsInit> = { [K in DefaultSelectKeys<Set>]: Set[K]['__outputType'] };
+  export type Input<Shape extends Column.QueryColumnsInit, AppReadOnly = { [K in keyof Shape]: Shape[K]['data']['appReadOnly'] extends true ? K : never }[keyof Shape], Optional extends keyof Shape = { [K in keyof Shape]: Shape[K]['data']['optional'] extends true ? K : never }[keyof Shape]> = { [K in Exclude<keyof Shape, AppReadOnly | Optional>]: Shape[K]['__inputType'] } & { [K in Exclude<Optional, AppReadOnly>]?: Shape[K]['__inputType'] };
+  export type InputPartial<Shape extends Column.QueryColumnsInit> = { [K in keyof Shape]?: Shape[K]['__inputType'] };
+  export type Output<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  export type DefaultSelectOutput<Shape extends Column.QueryColumnsInit> = { [K in { [K in keyof Shape]: Shape[K]['data']['explicitSelect'] extends true | undefined ? never : K }[keyof Shape]]: Shape[K]['__outputType'] };
+  export interface MapToObjectColumn<Shape extends Column.QueryColumns> {
+    dataType: 'object';
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify<ObjectOutput<Shape>>;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] };
+    operators: OperatorsAny;
+  }
+  export interface MapToNullableObjectColumn<Shape extends Column.QueryColumns> {
+    dataType: 'object';
+    __type: { [K in keyof Shape]: Shape[K]['__type'] };
+    __outputType: ShallowSimplify<ObjectOutput<Shape>> | undefined;
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] } | null;
+    operators: OperatorsAny;
+  }
+  export interface MapToPluckColumn<Shape extends Column.QueryColumns> {
+    dataType: 'array';
+    __type: Shape['pluck']['__type'][];
+    __outputType: Shape['pluck']['__outputType'][];
+    __queryType: Shape['pluck']['__queryType'][];
+    operators: OperatorsAny;
+  }
+  export interface MapToObjectArrayColumn<Shape extends Column.QueryColumns> {
+    dataType: 'array';
+    __type: { [K in keyof Shape]: Shape[K]['__type'] }[];
+    __outputType: ShallowSimplify<ObjectOutput<Shape>>[];
+    __queryType: { [K in keyof Shape]: Shape[K]['__queryType'] }[];
+    operators: OperatorsAny;
+  }
+  type ObjectOutput<Shape extends Column.QueryColumns> = { [K in keyof Shape]: Shape[K]['__outputType'] };
+  export {};
+}
+interface SelectSelf extends PickQuerySelectable, PickQueryHasSelect, PickQueryDefaultSelect, PickQueryShape, PickQueryRelations, PickQueryResult, PickQueryReturnType, PickQueryWithData {}
+type SelectArgs<T extends SelectSelf> = ('*' | keyof T['__selectable'])[];
+interface SubQueryAddition<T extends PickQueryWithData> extends IsSubQuery {
+  withData: T['withData'];
+}
+type SelectAsFnArg<T extends PickQueryRelationsWithData> = EmptyObject extends T['relations'] ? T : { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? RelationQueryMaybeSingle<T['relations'][K]> & SubQueryAddition<T> : K extends keyof T ? T[K] : never };
+interface SelectAsArg<T extends SelectSelf> {
+  [K: string]: keyof T['__selectable'] | Expression | ((q: SelectAsFnArg<T>) => unknown);
+}
+type SelectAsFnReturnType = {
+  result: Column.QueryColumns;
+  returnType: Exclude<QueryReturnType, 'rows'>;
+} | Expression;
+interface SelectAsCheckReturnTypes {
+  [K: string]: PropertyKey | Expression | ((q: never) => SelectAsFnReturnType);
+}
+type SelectReturnType<T extends PickQueryReturnType> = T['returnType'] extends 'valueOrThrow' ? 'oneOrThrow' : T extends 'value' ? 'one' : T['returnType'] extends 'pluck' ? 'all' : T['returnType'];
+type SelectResult<T extends SelectSelf, Columns extends PropertyKey[]> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends 'result' ? { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in '*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number] as T['__selectable'][K]['as']]: T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
+type SelectResultObj<T extends SelectSelf, Obj> = Obj extends SelectAsCheckReturnTypes ? { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never } : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? keyof Obj | keyof T['result'] : keyof Obj]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never }> : T[K] } : `Invalid return type of ${{ [K in keyof Obj]: Obj[K] extends ((...args: any[]) => any) ? ReturnType<Obj[K]> extends SelectAsFnReturnType ? never : K : never }[keyof Obj] & string}`;
+type SelectResultColumnsAndObj<T extends SelectSelf, Columns extends PropertyKey[], Obj> = { [K in keyof T]: K extends '__hasSelect' ? true : K extends '__selectable' ? T['__selectable'] & SelectAsSelectable<Obj> : K extends 'result' ? // Combine previously selected items, all columns if * was provided,
+{ [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown) : K extends 'returnType' ? SelectReturnType<T> : K extends 'then' ? QueryThenByReturnType<SelectReturnType<T>, { [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | T['__defaultSelect'] : Columns[number]) | keyof Obj as K extends Columns[number] ? T['__selectable'][K]['as'] : K]: K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : T['__selectable'][K]['column'] } & (T['__hasSelect'] extends (T['returnType'] extends 'value' | 'valueOrThrow' ? never : true) ? Omit<T['result'], Columns[number]> : unknown)> : T[K] };
+interface AllowedRelationOneQueryForSelectable extends IsSubQuery {
+  result: Column.QueryColumns;
+  returnType: 'value' | 'valueOrThrow' | 'one' | 'oneOrThrow';
+}
+type SelectAsSelectable<Obj> = UnionToIntersection<{ [K in keyof Obj]: Obj[K] extends ((q: never) => infer R extends AllowedRelationOneQueryForSelectable) ? { [C in R['returnType'] extends 'value' | 'valueOrThrow' ? K : keyof R['result'] as R['returnType'] extends 'value' | 'valueOrThrow' ? K : `${K & string}.${C & string}`]: {
+  as: C;
+  column: R['returnType'] extends 'value' | 'valueOrThrow' ? R['result']['value'] : R['result'][C & keyof R['result']];
+} } : never }[keyof Obj]>;
+type SelectAsValueResult<T extends SelectSelf, Arg> = Arg extends keyof T['__selectable'] ? T['__selectable'][Arg]['column'] : Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => IsQuery) ? SelectSubQueryResult<ReturnType<Arg>> : Arg extends ((q: never) => Expression) ? ReturnType<Arg>['result']['value'] : Arg extends ((q: never) => IsQuery | Expression) ? SelectSubQueryResult<Exclude<ReturnType<Arg>, Expression>> | Exclude<ReturnType<Arg>, IsQuery>['result']['value'] : never;
+type SelectSubQueryResult<Arg extends SelectSelf> = Arg['returnType'] extends undefined | 'all' ? ColumnsShape.MapToObjectArrayColumn<Arg['result']> : Arg['returnType'] extends 'value' | 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? ColumnsShape.MapToPluckColumn<Arg['result']> : Arg['returnType'] extends 'one' ? ColumnsShape.MapToNullableObjectColumn<Arg['result']> : ColumnsShape.MapToObjectColumn<Arg['result']>;
+declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>>(q: T, columns: Columns): SelectResult<T, Columns>;
+declare function _querySelect<T extends SelectSelf, Obj extends SelectAsArg<T>>(q: T, obj: Obj): SelectResultObj<T, Obj>;
+declare function _querySelect<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(q: T, args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
+declare class Select {
+  /**
+   * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
+   *
+   * The last argument can be an object. Keys of the object are column aliases, value can be a column name, sub-query, or raw SQL expression.
+   *
+   * ```ts
+   * import { sql } from './baseTable'
+   *
+   * // select columns of the table:
+   * db.table.select('id', 'name', { idAlias: 'id' });
+   *
+   * // accepts columns with table names:
+   * db.table.select('user.id', 'user.name', { nameAlias: 'user.name' });
+   *
+   * // table name may refer to the current table or a joined table:
+   * db.table
+   *   .join(db.message, 'authorId', 'user.id')
+   *   .select('user.name', 'message.text', { textAlias: 'message.text' });
+   *
+   * // select value from the sub-query,
+   * // this sub-query should return a single record and a single column:
+   * db.table.select({
+   *   subQueryResult: Otherdb.table.select('column').take(),
+   * });
+   *
+   * // select raw SQL value, specify the returning type via <generic> syntax:
+   * db.table.select({
+   *   raw: sql<number>`1 + 2`,
+   * });
+   *
+   * // select raw SQL value, the resulting type can be set by providing a column type in such way:
+   * db.table.select({
+   *   raw: sql`1 + 2`.type((t) => t.integer()),
+   * });
+   *
+   * // same raw SQL query as above, but the sql is returned from a callback
+   * db.table.select({
+   *   raw: () => sql`1 + 2`.type((t) => t.integer()),
+   * });
+   * ```
+   *
+   * When you use the ORM and defined relations, `select` can also accept callbacks with related table queries:
+   *
+   * ```ts
+   * await db.author.select({
+   *   allBooks: (q) => q.books,
+   *   firstBook: (q) => q.books.order({ createdAt: 'ASC' }).take(),
+   *   booksCount: (q) => q.books.count(),
+   * });
+   * ```
+   *
+   * When you're selecting a relation that's connected via `belongsTo` or `hasOne`, it becomes available to use in `order` or in `where`:
+   *
+   * ```ts
+   * // select books with their authors included, order by author name and filter by author column:
+   * await db.books
+   *   .select({
+   *     author: (q) => q.author,
+   *   })
+   *   .order('author.name')
+   *   .where({ 'author.isPopular': true });
+   * ```
+   */
+  select<T extends SelectSelf, Columns extends SelectArgs<T>>(this: T, ...args: Columns): SelectResult<T, Columns>;
+  select<T extends SelectSelf, Obj extends SelectAsArg<T>>(this: T, obj: Obj): SelectResultObj<T, Obj>;
+  select<T extends SelectSelf, Columns extends SelectArgs<T>, Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultColumnsAndObj<T, Columns, Obj>;
+  /**
+   * When querying the table or creating records, all columns are selected by default,
+   * but updating and deleting queries are returning affected row counts by default.
+   *
+   * Use `selectAll` to select all columns. If the `.select` method was applied before it will be discarded.
+   *
+   * ```ts
+   * const selectFull = await db.table
+   *   .select('id', 'name') // discarded by `selectAll`
+   *   .selectAll();
+   *
+   * const updatedFull = await db.table.selectAll().where(conditions).update(data);
+   *
+   * const deletedFull = await db.table.selectAll().where(conditions).delete();
+   * ```
+   */
+  selectAll<T extends SelectSelf>(this: T): SelectResult<T, ['*']>;
+}
 type SelectItem = string | SelectAs | Expression | undefined;
 interface SelectAs {
   selectAs: SelectAsValue;
@@ -6615,18 +6603,18 @@ declare namespace Column {
         unique: Name;
       };
     };
-    export type Nullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T | null> : T['operators'][K] } : T[K] };
+    export type Nullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
     export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K] };
     export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K] };
     interface DataNullable {
       isNullable: true;
       optional: true;
     }
-    export interface OperatorsNullable<T> {
-      equals: Operator<T | null>;
-      not: Operator<T | null>;
-      isDistinctFrom: Operator<T | null>;
-      isNotDistinctFrom: Operator<T | null>;
+    export interface OperatorsNullable<Column extends Column.Pick.QueryColumn> {
+      equals: Operator<Column['__queryType'] | null, Column>;
+      not: Operator<Column['__queryType'] | null, Column>;
+      isDistinctFrom: Operator<Column['__queryType'] | null, Column>;
+      isNotDistinctFrom: Operator<Column['__queryType'] | null, Column>;
     }
     export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
     export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
@@ -6819,6 +6807,8 @@ declare namespace Column {
     identity?: TableData.Identity;
     generated?: Data.Generated;
     readonly?: boolean;
+    valueToArray?: boolean;
+    skipValueToArray?: boolean;
   }
   export namespace Data {
     interface Check {
@@ -8742,11 +8732,13 @@ declare const getColumnBaseType: (column: Column.Pick.Data, domainsMap: DbStruct
 interface ColumnDataComputedProp extends ColumnDataSelectSqlProp {
   computed?: Expression;
 }
-type ComputedColumnsFromOptions<T extends ComputedOptionsFactory<never, never> | undefined> = T extends ((...args: any[]) => infer R extends ComputedOptionsConfig) ? { [K in keyof R]: R[K] extends QueryOrExpression<unknown> ? R[K]['result']['value'] : R[K] extends (() => {
+type ComputedColumnsFromOptions<Shape, Options> = Options extends {
+  computed: (...args: any) => infer R;
+} ? { [K in (keyof Shape | keyof R) & string]: K extends keyof Shape ? Shape[K] : K extends keyof R ? R[K] extends QueryOrExpression<unknown> ? R[K]['result']['value'] : R[K] extends (() => {
   result: {
     value: infer Value extends Column.Pick.QueryColumn;
   };
-}) ? Value : never } : EmptyObject;
+}) ? Value : never : never } : Shape;
 interface ComputedOptionsConfig {
   [K: string]: QueryOrExpression<unknown> | ReturnsQueryOrExpression<unknown>;
 }
@@ -8967,7 +8959,7 @@ type SelectAllColumn = string | SelectAllColumnExpression;
 interface QueryData extends QueryDataAliases, PickQueryDataParsers, HasHookSelect, MutativeQueriesSelectRelationsQueryData {
   type: QueryType;
   adapter: Adapter;
-  shape: ColumnsShape;
+  selectShape: ColumnsShape;
   handleResult: HandleResult;
   catch?: boolean;
   returnType: QueryReturnType;
@@ -9830,6 +9822,12 @@ declare class QueryUpsert {
    */
   upsert<T extends UpsertThis, Update extends UpdateData<T>>(this: T, data: UpsertData<T, Update>): UpsertResult<T>;
 }
+interface QueryGetSelf extends PickQuerySelectable, PickQueryRelationsWithData {}
+type GetArg<T extends QueryGetSelf> = GetStringArg<T> | Expression | ((q: SelectAsFnArg<T>) => Expression | Query.Pick.SingleValueResult);
+type GetStringArg<T extends PickQuerySelectable> = keyof T['__selectable'] & string;
+type ResolveGetArgColumn<Arg> = Arg extends Expression ? Arg['result']['value'] : Arg extends ((q: never) => infer R) ? R extends Expression ? R['result']['value'] : R extends Query.Pick.SingleValueResult ? R['result']['value'] : never : never;
+type GetResult<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOrThrow<T, Arg> : SetQueryReturnsColumnOrThrow<T, ResolveGetArgColumn<Arg>>;
+type GetResultOptional<T extends QueryGetSelf, Arg extends GetArg<T>> = Arg extends string ? SetQueryReturnsValueOptional<T, Arg> : SetQueryReturnsColumnOptional<T, ResolveGetArgColumn<Arg>>;
 declare class QueryGet {
   /**
    * `.get` returns a single value, adds `LIMIT 1` to the query, and accepts a column name or a raw SQL expression.
@@ -10111,6 +10109,28 @@ declare class QueryTruncate {
     cascade?: boolean;
   }): SetQueryReturnsVoid<T>;
 }
+declare class QueryExistsMethods {
+  /**
+   * Use `exists()` to check if there is at least one record-matching condition.
+   *
+   * It will discard previous `select` statements if any. Returns a boolean.
+   *
+   * ```ts
+   * const exists: boolean = await db.table.where(...conditions).exists();
+   * ```
+   */
+  exists<T extends QueryGetSelf>(this: T): SetQueryReturnsColumnOrThrow<T, BooleanQueryColumn>;
+  /**
+   * Use `notExists()` to check if there are no matching records.
+   *
+   * It will discard previous `select` statements if any. Returns a boolean.
+   *
+   * ```ts
+   * const exists: boolean = await db.table.where(...conditions).notExists();
+   * ```
+   */
+  notExists<T extends QueryGetSelf>(this: T): SetQueryReturnsColumnOrThrow<T, BooleanQueryColumn>;
+}
 type GroupArgs<T extends PickQueryResult> = ({ [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' | 'runtimeComputed' ? never : K }[keyof T['result']] | Expression)[];
 interface QueryHelperQuery<T extends PickQuerySelectableShapeAs> extends MergeQueryArg {
   returnType: QueryReturnType;
@@ -10149,7 +10169,7 @@ interface NarrowPluckTypeResult<T extends PickQueryResultReturnType, Narrow> ext
 }
 type QueryIfResult<T extends PickQueryResultReturnType, R extends PickQueryResult> = { [K in keyof T]: K extends 'result' ? { [K in keyof T['result'] | keyof R['result']]: K extends keyof T['result'] ? K extends keyof R['result'] ? R['result'][K] | T['result'][K] : T['result'][K] : Column.Modifiers.QueryColumnToOptional<R['result'][K]> } : K extends 'then' ? QueryIfResultThen<T, R> : T[K] };
 type QueryIfResultThen<T extends PickQueryResultReturnType, R extends PickQueryResult> = T['returnType'] extends undefined | 'all' ? QueryThenShallowSimplifyArr<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'one' ? QueryThenShallowSimplifyOptional<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'oneOrThrow' ? QueryThenShallowSimplify<{ [K in keyof T['result']]: K extends keyof R['result'] ? T['result'][K]['__outputType'] | R['result'][K]['__outputType'] : T['result'][K]['__outputType'] } & { [K in keyof R['result'] as K extends keyof T['result'] ? never : K]?: R['result'][K]['__outputType'] }> : T['returnType'] extends 'value' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType'] | undefined> : T['returnType'] extends 'valueOrThrow' ? QueryThen<T['result']['value']['__outputType'] | R['result']['value']['__outputType']> : T['returnType'] extends 'rows' ? QueryThen<(T['result'][keyof T['result']]['__outputType'] | R['result'][keyof R['result']]['__outputType'])[][]> : T['returnType'] extends 'pluck' ? QueryThen<(T['result']['pluck']['__outputType'] | R['result']['pluck']['__outputType'])[]> : QueryThen<void>;
-interface QueryMethods<ColumnTypes> extends QueryClone, QueryAsMethods, AggregateMethods, QueryDistinct, Select, FromMethods, QueryJoin, QueryLimitOffset, CteQuery, Union, QueryJsonMethods, QueryCreate, QueryCreateFrom, QueryUpdate, QueryDelete, QueryStorage, QueryTransaction, QueryTruncate, For, Where, SearchMethods, Clear, Having, QueryCatchers, QueryLog, QueryOrder, QueryWithSchema, QueryHooks, QueryUpsert, QueryOrCreate, QueryGet, QueryPluck, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow {}
+interface QueryMethods<ColumnTypes> extends QueryClone, QueryAsMethods, AggregateMethods, QueryDistinct, Select, FromMethods, QueryJoin, QueryLimitOffset, CteQuery, Union, QueryJsonMethods, QueryCreate, QueryCreateFrom, QueryUpdate, QueryDelete, QueryStorage, QueryTransaction, QueryTruncate, For, Where, SearchMethods, Clear, Having, QueryCatchers, QueryLog, QueryOrder, QueryWithSchema, QueryHooks, QueryUpsert, QueryOrCreate, QueryGet, QueryPluck, MergeQueryMethods, QuerySql<ColumnTypes>, QueryTransform, QueryMap, QueryScope, SoftDeleteMethods, QueryExpressions, QueryWrap, QueryWindow, QueryExistsMethods {}
 declare class QueryMethods<ColumnTypes> {
   /**
    * `.all` is a default behavior, that returns an array of objects:
@@ -10212,6 +10232,15 @@ declare class QueryMethods<ColumnTypes> {
    * ```
    */
   exec<T>(this: T): SetQueryReturnsVoid<T>;
+  /**
+   * For relation selects, `require` changes LEFT JOIN LATERAL to JOIN LATERAL.
+   *
+   * ```ts
+   * // only the records that have `related` will be loaded:
+   * await db.table.select({ related: (q) => q.related.required() });
+   * ```
+   */
+  require<T extends PickQueryResultReturnType>(this: T): QueryRequire<T>;
   /**
    * Call `toSQL` on a query to get an object with a `text` SQL string and a `values` array of binding values:
    *
@@ -10400,7 +10429,7 @@ declare class QueryMethods<ColumnTypes> {
    * // all the following queries will resolve into empty arrays
    *
    * await db.user.select({
-   *   pets: (q) => q.pets.join().none(),
+   *   pets: (q) => q.pets.require().none(),
    * });
    *
    * await db.user.join((q) => q.pets.none());
@@ -10472,7 +10501,7 @@ declare class QueryMethods<ColumnTypes> {
    *
    * @param fn - helper function
    */
-  makeHelper<T extends PickQuerySelectableShapeAs, Args extends unknown[], Result extends MergeQueryArg>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
+  makeHelper<T extends PickQuerySelectableShapeAs, Args extends unknown[], Result extends MergeQueryArg | Expression>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
   /**
    * `useHelper` allows to use {@link makeHelper} in different queries:
    *
@@ -10681,6 +10710,9 @@ declare namespace Query {
     type Args<T extends Order.ArgThis> = Order.Args<T>;
   }
   namespace Pick {
+    interface ReturnType {
+      returnType: QueryReturnType;
+    }
     interface SingleValueResult {
       result: {
         value: Column.Pick.OutputType;
@@ -10701,6 +10733,7 @@ type SetQueryReturnsAll<T extends PickQueryResult> = { [K in keyof T]: K extends
 type SetQueryReturnsAllResult<T extends PickQueryResult, Result extends Column.QueryColumns> = { [K in keyof T]: K extends 'returnType' ? 'all' : K extends 'result' ? Result : K extends 'then' ? QueryThenShallowSimplifyArr<T['result']> : T[K] } & QueryHasWhere;
 type QueryTakeOptional<T extends PickQueryResultReturnType> = T['returnType'] extends 'value' | 'pluck' | 'void' ? T : T['returnType'] extends 'valueOrThrow' ? { [K in keyof T]: K extends 'returnType' ? 'value' : K extends 'then' ? QueryThen<T['result']['value']['__outputType'] | undefined> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K] };
 type QueryManyTakeOptional<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'one' : K extends 'then' ? QueryThenShallowSimplifyOptional<ColumnsShape.Output<T['result']>> : T[K] };
+type QueryRequire<T extends PickQueryResultReturnType> = T['returnType'] extends QueryReturnTypeAll | 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
 type QueryTake<T extends PickQueryResultReturnType> = T['returnType'] extends 'valueOrThrow' | 'pluck' | 'void' ? T : T['returnType'] extends 'value' ? { [K in keyof T]: K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<Exclude<T['result']['value']['__outputType'], undefined>> : T[K] } : { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
 type QueryManyTake<T extends PickQueryResultReturnType> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
 type SetQueryReturnsOne<T extends PickQueryResult> = { [K in keyof T]: K extends 'returnType' ? 'oneOrThrow' : K extends 'then' ? QueryThenShallowSimplify<ColumnsShape.Output<T['result']>> : T[K] };
@@ -11106,4 +11139,4 @@ declare const testTransaction: {
    */
   close(arg: Arg$1): Promise<void>;
 };
-export { type Adapter, AdapterClass, type AdapterConfigBase, type AdapterParams, type AdapterSchemaConfigOptions, type AfterCommitStandaloneHook, type AfterHook, ArrayColumn, type ArrayColumnValue, type ArrayData, type AsyncState, type BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, type ColumnsShape, type ComputedColumnsFromOptions, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbExtension, type DbOptions, type DbResult, type DbSharedOptions, type DbSqlMethod, type DbStructureDomainsMap, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultPrivileges, type DefaultSchemaConfig, type DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, type DriverAdapter, DynamicRawSQL, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionData, type FromArg, type FromResult, type GeneratorIgnore, type Grant, type HookSelectValue, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinQueryMethod, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, type OperatorsText, OrchidOrmInternalError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type Query, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, QueryError, type QueryHasWhere, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryInternal, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, type QueryOrExpression, type QueryResult, type QueryResultRow, type QueryReturnType, type QuerySchema, type QueryScopes, RawSql, type RawSqlBase, RealColumn, type RecordKeyTrue, type RecordOptionalString, type RecordString, type RecordStringOrNumber, type RecordUnknown, type RefreshMaterializedViewOptions, type RelationConfigBase, type RelationJoinQuery, type RelationsBase, type Rls, type RlsPolicy, type SchemaConfigFnWithOptions, type SearchWeight, type SelectableFromShape, SerialColumn, type SerialColumnData, type ShallowSimplify, type ShapeColumnPrimaryKeys, type ShapeUniqueColumns, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type Sql, type SqlFn, type SqlSessionState, type StorageOptions, StringColumn, type StringData, type TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TemplateLiteralArgs, TextBaseColumn, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSqlValues, type TransactionAdapter, TransactionAdapterClass, type TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, type UniqueConstraints, type UniqueTableDataItem, UnknownColumn, type UpdateData, type UpsertData, type UpsertThis, VarCharColumn, VirtualColumn, type WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, copyTableData, createDbWithAdapter, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, refreshMaterializedView, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, testTransaction, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };
+export { type Adapter, AdapterClass, type AdapterConfigBase, type AdapterParams, type AdapterSchemaConfigOptions, type AfterCommitStandaloneHook, type AfterHook, ArrayColumn, type ArrayColumnValue, type ArrayData, type AsyncState, type BaseNumberData, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, type Code, type Codes, Column, type ColumnFromDbParams, type ColumnSchemaConfig, type ColumnSchemaGetterColumns, type ColumnSchemaGetterTableClass, type ColumnToCodeCtx, type ColumnTypeSchemaArg, type ColumnsByType, type ColumnsShape, type ComputedColumnsFromOptions, type ComputedOptionsConfig, type ComputedOptionsFactory, type CreateCtx, type CreateData, type CreateManyMethodsNames, type CreateMethodsNames, type CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, type DateColumnData, DateTimeBaseClass, DateTimeTzBaseClass, Db, type DbDomainArg, type DbExtension, type DbOptions, type DbResult, type DbSharedOptions, type DbSqlMethod, type DbStructureDomainsMap, type DbTableOptionScopes, type DbTableOptions, DecimalColumn, type DecimalColumnData, type DefaultColumnTypes, type DefaultPrivileges, type DefaultSchemaConfig, type DeleteMethodsNames, DomainColumn, DoublePrecisionColumn, type DriverAdapter, DynamicRawSQL, type EmptyObject, type EmptyTuple, EnumColumn, Expression, type ExpressionData, type FromArg, type FromResult, type GeneratorIgnore, type Grant, type HookSelectValue, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, type IsQuery, type IsolationLevel, JSONColumn, JSONTextColumn, type JoinedShapes, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, type MapTableScopesOption, type MaybeArray, type MaybePromise, type MergeQuery, MoneyColumn, type NoPrimaryKeyOption, type NonUniqDataItem, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, type NumberColumnData, Operators, type OperatorsArray, type OperatorsJson, type OperatorsOrdinalText, type OperatorsText, OrchidOrmInternalError, type Ord, PathColumn, type PickQueryInputType, type PickQueryInternal, type PickQueryQ, type PickQueryRelations, type PickQuerySelectableRelations, type PickQueryShape, PointColumn, PolygonColumn, PostgisGeographyPointColumn, type Query, type QueryAfterHook, type QueryBeforeActionHook, type QueryBeforeHook, type QueryData, QueryError, type QueryHasWhere, type QueryHelperResult, QueryHookUtils, QueryHooks, type QueryInternal, type QueryLogObject, type QueryLogOptions, type QueryLogger, type QueryManyTake, type QueryManyTakeOptional, type QueryOrExpression, type QueryResult, type QueryResultRow, type QueryReturnType, type QuerySchema, type QueryScopes, RawSql, type RawSqlBase, RealColumn, type RecordKeyTrue, type RecordOptionalString, type RecordString, type RecordStringOrNumber, type RecordUnknown, type RefreshMaterializedViewOptions, type RelationConfigBase, type RelationJoinQuery, type RelationsBase, type Rls, type RlsPolicy, type SchemaConfigFnWithOptions, type SearchWeight, type SelectableFromShape, SerialColumn, type SerialColumnData, type ShallowSimplify, type ShapeUniqueColumns, type SingleSql, type SingleSqlItem, SmallIntColumn, SmallSerialColumn, type Sql, type SqlFn, type SqlSessionState, type StorageOptions, StringColumn, type StringData, type TableData, type TableDataFn, type TableDataInput, type TableDataItem, type TableDataItemsUniqueColumnTuples, type TableDataItemsUniqueColumns, type TableDataItemsUniqueConstraints, type TableDataMethods, type TemplateLiteralArgs, TextBaseColumn, TextColumn, TimeColumn, TimestampColumn, TimestampTZColumn, type Timestamps, type ToSQLCtx, type ToSqlValues, type TransactionAdapter, TransactionAdapterClass, type TransactionOptions, TsQueryColumn, TsVectorColumn, UUIDColumn, type UniqueConstraints, type UniqueTableDataItem, UnknownColumn, type UpdateData, type UpsertData, type UpsertThis, VarCharColumn, VirtualColumn, type WhereArg, XMLColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _orCreate, _prependWith, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, addCode, addTopCte, addTopCteSql, applyMixins, assignDbDataToColumn, backtickQuote, cloneQueryBaseUnscoped, codeToString, colors, columnsShapeToCode, constraintInnerToCode, consumeColumnName, copyTableData, createDbWithAdapter, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForMigration, escapeString, excludeInnerToCode, exhaustive, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getDateAsDateFn, getDateAsNumberFn, getDriverErrorCode, getFreeAlias, getFreeSetAlias, getImportPath, getPrimaryKeys, getQueryAs, getQuerySchema, getShapeFromSelect, getSqlText, getStackTrace, getSupportedDefaultPrivileges, indexInnerToCode, internalSchemaConfig, isExpression, isQueryReturnsAll, isRawSQL, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeConnectRetryConfig, noop, objectHasValues, omit, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, prepareSubQueryForSql, primaryKeyInnerToCode, pushQueryOnForOuter, pushQueryValueImmutable, pushTableDataCode, queryToSql, quoteIdentifier, quoteObjectKey, quoteTableWithSchema, raw, rawSqlToCode, rawSqlToSql, referencesArgsToCode, refreshMaterializedView, returnArg, setColumnData, setColumnEncode, setColumnParse, setColumnParseNull, setCurrentColumnName, setDataValue, setDefaultLanguage, setFreeAlias, setQueryObjectValueImmutable, singleQuote, sqlToRawSql, tableDataMethods, testTransaction, toArray, toCamelCase, toPascalCase, toSnakeCase, wrapAdapterFnWithConnectRetry };