pqb 0.30.2 → 0.30.4

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, FnUnknownToUnknown, ExpressionChain, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, PickQueryMetaShape, PickQueryTableMetaResultShape, QueryColumnBooleanOrNull, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, PickQueryMetaResult, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, PickQueryMetaResultWindows, CoreBaseOperators, PickQueryUniqueProperties, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, ExpressionData, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, PickOutputType, PickQueryMetaReturnType, UniqueColumn, TimestampHelpers, Codes, ColumnDataCheckBase, PickQueryTableMetaShape } from 'orchid-core';
+import { QueryResultRow, AdapterConfigBase, AdapterBase, QueryInput, Sql, RecordUnknown, RecordKeyTrue, EmptyObject, QueryBaseCommon, QueryColumns, QueryMetaBase, QueryReturnType, QueryThen, Expression, QueryColumn, MaybeArray, SelectableBase, TemplateLiteralArgs, PickOutputTypeAndOperators, PickQueryResult, OperatorToSQL, ColumnsShapeBase, ColumnsParsers, RecordString, PickQueryTable, FnUnknownToUnknown, ExpressionChain, getValueKey, PickQueryShape, PickQueryTableMetaResult, EmptyTuple, PickQueryMeta, PickQueryMetaResultReturnType, QueryColumnToNullable, PickQueryMetaShape, PickQueryTableMetaResultShape, PickQueryMetaResultWindows, QueryColumnBooleanOrNull, ExpressionData, ValExpression, PickOutputType, SQLQueryArgs, ColumnSchemaConfig, DateColumnData, Code, TimeInterval, ColumnTypeSchemaArg, ColumnDataBase, ArrayMethodsData, RawSQLBase, RawSQLValues, ExpressionTypeMethod, DynamicSQLArg, StaticSQLArgs, ForeignKeyTable, ColumnNameOfTable, BaseNumberData, PickColumnBaseData, ColumnWithDefault, StringTypeData, PrimaryKeyColumn, ParseColumn, EncodeColumn, PickQueryMetaResult, QueryColumnsInit, DefaultSelectColumns, CoreQueryScopes, DbBase, QueryCatch, TransactionState, ColumnTypeBase, CoreBaseOperators, PickQueryUniqueProperties, IsQuery, PickQueryMetaShapeResultReturnType, MergeObjects, PickQueryResultUniqueColumns, QueryInternalBase, PickQueryReturnType, PickType, ColumnShapeOutput, PickQueryMetaReturnType, UniqueColumn, TimestampHelpers, Codes, ColumnDataCheckBase, PickQueryTableMetaShape } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -1054,7 +1054,8 @@ declare class Join {
      * ```ts
      * db.user.join(
      *   db.message,
-     *   db.user.sql`lower("message"."text") = lower("user"."name")`,
+     *   // `sql` can be imported from your `BaseTable` file
+     *   sql`lower("message"."text") = lower("user"."name")`,
      * );
      * ```
      *
@@ -1063,16 +1064,16 @@ declare class Join {
      * ```ts
      * db.user.join(
      *   db.message,
-     *   db.user.sql`lower("message"."text")`,
-     *   db.user.sql`lower("user"."name")`,
+     *   sql`lower("message"."text")`,
+     *   sql`lower("user"."name")`,
      * );
      *
      * // with operator:
      * db.user.join(
      *   db.message,
-     *   db.user.sql`lower("message"."text")`,
+     *   sql`lower("message"."text")`,
      *   '!=',
-     *   db.user.sql`lower("user"."name")`,
+     *   sql`lower("user"."name")`,
      * );
      * ```
      *
@@ -1086,7 +1087,7 @@ declare class Join {
      *   'message.userId': 'user.id',
      *
      *   // value can be a raw SQL expression:
-     *   text: db.user.sql`lower("user"."name")`,
+     *   text: sql`lower("user"."name")`,
      * });
      * ```
      *
@@ -1426,12 +1427,184 @@ declare class OnMethods {
     onJsonPathEquals<T extends PickQueryMeta>(this: T, ...args: OnJsonPathEqualsArgs<T['meta']['selectable']>): T;
 }
 
+interface AggregateOptions<T extends PickQueryMetaResultRelationsWindows> {
+    distinct?: boolean;
+    order?: OrderArg<T> | OrderArg<T>[];
+    filter?: WhereArg<T>;
+    filterOr?: WhereArg<T>[];
+    withinGroup?: boolean;
+    over?: Over<T>;
+}
+type Over<T extends PickQueryMetaResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
+type FnExpressionArgs<Q extends PickQueryMeta> = (SelectableOrExpression<Q> | FnExpressionArgsPairs<Q> | FnExpressionArgsValue)[];
+interface FnExpressionArgsPairs<Q extends PickQueryMeta> {
+    pairs: {
+        [K: string]: SelectableOrExpression<Q>;
+    };
+}
+interface FnExpressionArgsValue {
+    value: unknown;
+}
+declare class FnExpression<Q extends Query = Query, T extends QueryColumn = QueryColumn> extends Expression<T> {
+    query: Q;
+    fn: string;
+    args: FnExpressionArgs<Q>;
+    options: AggregateOptions<Q>;
+    result: {
+        value: T;
+    };
+    q: QueryData;
+    /**
+     * @param query - query object.
+     * @param fn - SQL function name.
+     * @param args - arguments of the function.
+     * @param options - aggregate options.
+     * @param value - column type of the function result.
+     */
+    constructor(query: Q, fn: string, args: FnExpressionArgs<Q>, options: AggregateOptions<Q>, value: T);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+type ColumnExpression<C extends QueryColumn, Ops extends BaseOperators = C['operators']> = Expression<C> & {
+    [K in keyof Ops]: (arg: Ops[K]['_opType']) => ColumnExpression<QueryColumnBooleanOrNull>;
+};
+declare function makeFnExpression<T extends PickQueryMetaResultRelationsWindows, C extends QueryColumn>(self: T, type: C, fn: string, args: FnExpressionArgs<Query>, options?: AggregateOptions<T>): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
+
+declare class ColumnRefExpression<T extends QueryColumn> extends Expression<T> {
+    name: string;
+    result: {
+        value: T;
+    };
+    q: ExpressionData;
+    constructor(value: T, name: string);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+declare class RefExpression<T extends QueryColumn> extends Expression<T> {
+    q: QueryData;
+    ref: string;
+    result: {
+        value: T;
+    };
+    constructor(value: T, q: QueryData, ref: string);
+    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
+}
+type OrExpressionArg = QueryOrExpressionBooleanOrNullResult | undefined;
+interface OrExpression extends Expression<BooleanQueryColumn>, OperatorsBoolean {
+}
+declare class OrExpression extends Expression<BooleanQueryColumn> {
+    args: [OrExpressionArg, ...OrExpressionArg[]];
+    result: {
+        value: BooleanQueryColumn;
+    };
+    q: ExpressionData;
+    constructor(args: [OrExpressionArg, ...OrExpressionArg[]]);
+    makeSQL(ctx: {
+        values: unknown[];
+    }, quotedAs?: string): string;
+}
+interface QueryReturnsFnAdd<T extends PickQueryColumnTypes> extends QueryMetaHasSelect {
+    type<C extends QueryColumn>(fn: (types: T['columnTypes']) => C): {
+        [K in keyof T]: K extends 'result' ? {
+            value: C;
+        } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['outputType']> : T[K];
+    } & C['operators'];
+}
+type SetQueryReturnsFn<T extends PickQueryColumnTypes, C extends PickOutputType> = {
+    [K in keyof T]: K extends 'result' ? {
+        value: C;
+    } : K extends 'returnType' ? 'valueOrThrow' : K extends 'then' ? QueryThen<C['outputType']> : T[K];
+} & QueryReturnsFnAdd<T>;
+declare class ExpressionMethods {
+    /**
+     * `column` references a table column, this can be used in raw SQL or when building a column expression.
+     * Only for referencing a column in the query's table. For referencing joined table's columns, see [ref](#ref).
+     *
+     * ```ts
+     * await db.table.select({
+     *   // select `("table"."id" = 1 OR "table"."name" = 'name') AS "one"`,
+     *   // returns a boolean
+     *   one: (q) =>
+     *     q.sql<boolean>`${q.column('id')} = ${1} OR ${q.column('name')} = ${'name'}`,
+     *
+     *   // selects the same as above, but by building a query
+     *   two: (q) => q.column('id').equals(1).or(q.column('name').equals('name')),
+     * });
+     * ```
+     *
+     * @param name - column name
+     */
+    column<T extends PickQueryShape, K extends keyof T['shape']>(this: T, name: K): ColumnRefExpression<T['shape'][K]> & T['shape'][K]['operators'];
+    /**
+     * `ref` is similar to [column](#column), but it also allows to reference a column of joined table,
+     * and other dynamically defined columns.
+     *
+     * ```ts
+     * await db.table.join('otherTable').select({
+     *   // select `("otherTable"."id" = 1 OR "otherTable"."name" = 'name') AS "one"`,
+     *   // returns a boolean
+     *   one: (q) =>
+     *     q.sql<boolean>`${q.ref('otherTable.id')} = ${1} OR ${q.ref(
+     *       'otherTable.name',
+     *     )} = ${'name'}`,
+     *
+     *   // selects the same as above, but by building a query
+     *   two: (q) =>
+     *     q
+     *       .ref('otherTable.id')
+     *       .equals(1)
+     *       .or(q.ref('otherTable.name').equals('name')),
+     * });
+     * ```
+     *
+     * @param arg - any available column name, such as of a joined table
+     */
+    ref<T extends PickQueryMeta, K extends keyof T['meta']['selectable'] & string>(this: T, arg: K): RefExpression<T['meta']['selectable'][K]['column']> & T['meta']['selectable'][K]['column']['operators'];
+    val(value: unknown): ValExpression;
+    /**
+     * `fn` allows to call an arbitrary SQL function.
+     *
+     * For example, calling `sqrt` function to get a square root from some numeric column:
+     *
+     * ```ts
+     * const q = await User.select({
+     *   sqrt: (q) => q.fn<number>('sqrt', ['numericColumn']),
+     * }).take();
+     *
+     * q.sqrt; // has type `number` just as provided
+     * ```
+     *
+     * If this is an aggregate function, you can specify aggregation options (see [Aggregate](/guide/aggregate.html)) via third parameter.
+     *
+     * Use `type` method to specify a column type so that its operators such as `lt` and `gt` become available:
+     *
+     * ```ts
+     * const q = await User.select({
+     *   // Produces `sqrt("numericColumn") > 5`
+     *   sqrtIsGreaterThan5: (q) =>
+     *     q
+     *       .fn('sqrt', ['numericColumn'])
+     *       .type((t) => t.float())
+     *       .gt(5),
+     * }).take();
+     *
+     * // Return type is boolean | null
+     * // todo: it should be just boolean if the column is not nullable, but for now it's always nullable
+     * q.sqrtIsGreaterThan5;
+     * ```
+     *
+     * @param fn
+     * @param args
+     * @param options
+     */
+    fn<T extends PickQueryMetaResultRelationsWindowsColumnTypes, Type = unknown, C extends QueryColumn = QueryColumn<Type>>(this: T, fn: string, args: SelectableOrExpression<T>[], options?: AggregateOptions<T>): SetQueryReturnsFn<T, C>;
+    or(...args: [OrExpressionArg, ...OrExpressionArg[]]): OrExpression;
+}
+
 type WhereArg<T extends PickQueryMetaRelations> = {
     [K in keyof T['meta']['selectable'] | 'NOT' | 'OR' | 'IN']?: K extends 'NOT' ? MaybeArray<WhereArg<T>> : K extends 'OR' ? MaybeArray<WhereArg<T>>[] : K extends 'IN' ? MaybeArray<{
         columns: (keyof T['meta']['selectable'])[];
         values: unknown[][] | QueryBase | Expression;
-    }> : T['meta']['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['meta']['selectable'], K> | Expression | QueryBase;
-} | QueryBase | Expression<QueryColumnBooleanOrNull> | ((q: WhereQueryBuilder<T>) => QueryColumnBooleanOrNull | QueryBaseThen<boolean | null> | WhereQueryBuilder<T>);
+    }> : T['meta']['selectable'][K]['column']['queryType'] | null | ColumnOperators<T['meta']['selectable'], K> | QueryOrExpression<T['meta']['selectable'][K]['column']['queryType'] | null> | ((q: T) => QueryOrExpression<T['meta']['selectable'][K]['column']['queryType'] | null>);
+} | QueryOrExpressionBooleanOrNullResult | ((q: WhereQueryBuilder<T>) => QueryOrExpressionBooleanOrNullResult | WhereQueryBuilder<T>);
 /**
  * Callback argument of `where`.
  * It has `where` methods (`where`, `whereNot`, `whereExists`, etc.),
@@ -1441,9 +1614,9 @@ type WhereArg<T extends PickQueryMetaRelations> = {
  * ```
  */
 type WhereQueryBuilder<T extends PickQueryRelations> = RelationsBase extends T['relations'] ? {
-    [K in keyof T]: K extends keyof QueryBase | keyof Where ? T[K] : never;
+    [K in keyof T]: K extends keyof QueryBase | keyof Where | keyof ExpressionMethods | 'sql' ? T[K] : never;
 } : {
-    [K in keyof T]: K extends keyof T['relations'] ? T['relations'][K] : T[K];
+    [K in keyof T]: K extends keyof T['relations'] ? T['relations'][K] : K extends keyof QueryBase | keyof Where | keyof ExpressionMethods | 'sql' ? T[K] : never;
 };
 type WhereArgs<T extends PickQueryMetaRelations> = WhereArg<T>[];
 type WhereNotArgs<T extends PickQueryMetaRelations> = [WhereArg<T>];
@@ -1515,7 +1688,13 @@ declare class Where {
      *   },
      *
      *   // where column equals to raw SQL
-     *   column: db.table.sql`sql expression`,
+     *   // import `sql` from your `BaseTable`
+     *   column: sql`sql expression`,
+     *   // or use `(q) => q.sql` for the same
+     *   column2: (q) => q.sql`sql expression`,
+     *
+     *   // reference other columns in such a way:
+     *   firstName: (q) => q.ref('lastName'),
      * });
      * ```
      *
@@ -1564,12 +1743,7 @@ declare class Where {
      * `where` supports raw SQL:
      *
      * ```ts
-     * db.table.where(db.table.sql`a = b`);
-     *
-     * // or
-     * import { raw } from 'orchid-orm';
-     *
-     * db.table.where(raw`a = b`);
+     * db.table.where(sql`a = b`);
      * ```
      *
      * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `orWhere`, `whereNot`, `whereIn`, `whereExists`:
@@ -1590,7 +1764,7 @@ declare class Where {
      * db.table.where(
      *   { id: 1 },
      *   db.table.where({ name: 'John' }),
-     *   db.table.sql`a = b`,
+     *   sql`a = b`,
      * );
      * ```
      *
@@ -1703,8 +1877,6 @@ declare class Where {
      * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
      *
      * ```ts
-     * import { sql } from 'orchid-orm';
-     *
      * db.table.where({
      *   numericColumn: {
      *     // lower than 5
@@ -1753,7 +1925,7 @@ declare class Where {
      *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
      *     in: OtherTable.select('column'),
      *
-     *     in: db.table.sql`('a', 'b')`,
+     *     in: sql`('a', 'b')`,
      *   },
      * });
      * ```
@@ -1800,7 +1972,7 @@ declare class Where {
      *     between: [1, 10],
      *
      *     // sub-query and raw SQL expression
-     *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
+     *     between: [OtherTable.select('column').take(), sql`2 + 2`],
      *   },
      * });
      * ```
@@ -1887,15 +2059,7 @@ declare class Where {
      * Use a custom SQL expression in `WHERE` statement:
      *
      * ```ts
-     * db.table.where`a = b`;
-     *
-     * // or
-     * db.table.where(db.table.sql`a = b`);
-     *
-     * // or
-     * import { raw } from 'orchid-orm';
-     *
-     * db.table.where(raw`a = b`);
+     * db.table.whereSql`a = b`;
      * ```
      *
      * @param args - SQL expression
@@ -1918,10 +2082,10 @@ declare class Where {
      */
     whereNot<T extends PickQueryMetaRelations>(this: T, ...args: WhereNotArgs<T>): WhereResult<T>;
     /**
-     * `whereNot` version accepting SQL expression:
+     * `whereNotSql` is a version of `whereNot` accepting SQL expression:
      *
      * ```ts
-     * db.table.whereNot`sql expression`
+     * db.table.whereNotSql`sql expression`
      * ```
      *
      * @param args - SQL expression
@@ -1989,7 +2153,7 @@ declare class Where {
      * It supports raw SQL expression:
      *
      * ```ts
-     * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+     * db.table.whereIn(['id', 'name'], sql`((1, 'one'), (2, 'two'))`);
      * ```
      */
     whereIn<T extends PickQueryMetaRelations, Column extends WhereInColumn<T>>(this: T, ...args: [column: Column, values: WhereInValues<T, Column>] | [arg: WhereInArg<T>]): WhereResult<T>;
@@ -3144,48 +3308,6 @@ declare const resolveSubQueryCallback: (q: ToSQLQuery, cb: (q: ToSQLQuery) => To
  */
 declare const joinSubQuery: (q: ToSQLQuery, sub: ToSQLQuery) => Query;
 
-interface AggregateOptions<T extends PickQueryMetaResultRelationsWindows> {
-    distinct?: boolean;
-    order?: OrderArg<T> | OrderArg<T>[];
-    filter?: WhereArg<T>;
-    filterOr?: WhereArg<T>[];
-    withinGroup?: boolean;
-    over?: Over<T>;
-}
-type Over<T extends PickQueryMetaResultWindows> = keyof T['windows'] | WindowArgDeclaration<T>;
-type FnExpressionArgs<Q extends PickQueryMeta> = (SelectableOrExpression<Q> | FnExpressionArgsPairs<Q> | FnExpressionArgsValue)[];
-interface FnExpressionArgsPairs<Q extends PickQueryMeta> {
-    pairs: {
-        [K: string]: SelectableOrExpression<Q>;
-    };
-}
-interface FnExpressionArgsValue {
-    value: unknown;
-}
-declare class FnExpression<Q extends Query = Query, T extends QueryColumn = QueryColumn> extends Expression<T> {
-    query: Q;
-    fn: string;
-    args: FnExpressionArgs<Q>;
-    options: AggregateOptions<Q>;
-    result: {
-        value: T;
-    };
-    q: QueryData;
-    /**
-     * @param query - query object.
-     * @param fn - SQL function name.
-     * @param args - arguments of the function.
-     * @param options - aggregate options.
-     * @param value - column type of the function result.
-     */
-    constructor(query: Q, fn: string, args: FnExpressionArgs<Q>, options: AggregateOptions<Q>, value: T);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
-type ColumnExpression<C extends QueryColumn, Ops extends BaseOperators = C['operators']> = Expression<C> & {
-    [K in keyof Ops]: (arg: Ops[K]['_opType']) => ColumnExpression<QueryColumnBooleanOrNull>;
-};
-declare function makeFnExpression<T extends PickQueryMetaResultRelationsWindows, C extends QueryColumn>(self: T, type: C, fn: string, args: FnExpressionArgs<Query>, options?: AggregateOptions<T>): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
-
 type QueryGetSelf = PickQueryMetaTable;
 type GetArg<T extends QueryGetSelf> = GetStringArg<T> | Expression;
 type GetStringArg<T extends PickQueryMeta> = keyof T['meta']['selectable'] & string;
@@ -3232,41 +3354,6 @@ type StringColumn = QueryColumn<string, OperatorsText>;
 type StringNullable = QueryColumn<string | null, OperatorsText>;
 type NullableStringReturn<T> = SetQueryReturnsColumnOrThrow<T, StringNullable> & OperatorsText;
 declare class AggregateMethods {
-    /**
-     * `fn` allows to call an arbitrary SQL function.
-     *
-     * For example, calling `sqrt` function to get a square root from some numeric column:
-     *
-     * ```ts
-     * const q = await User.select({
-     *   // todo: use type callback instead of generic type
-     *   sqrt: (q) => q.fn<number>('sqrt', ['numericColumn']),
-     * }).take();
-     *
-     * q.sqrt; // has type `number` just as provided
-     * ```
-     *
-     * If this is an aggregate function, you can specify aggregation options via third parameter.
-     *
-     * Forth parameter is for runtime column type. When specified, allows to chain the function with the column operators:
-     *
-     * ```ts
-     * const q = await User.select({
-     *   // chain `sqrt("numericColumn")` with the "greater than 5"
-     *   sqrtIsGreaterThan5: (q) => q.fn('sqrt', ['numericColumn'], {}, (t) => t.float()).gt(5),
-     * }).take();
-     *
-     * // Return type is boolean | null
-     * // todo: it should be just boolean if the column is not nullable, but for now it's always nullable
-     * q.sqrtIsGreaterThan5
-     * ```
-     *
-     * @param fn
-     * @param args
-     * @param options
-     * @param type
-     */
-    fn<T extends PickQueryMetaResultRelationsWindowsColumnTypes, Type = unknown, C extends QueryColumn = QueryColumn<Type>>(this: T, fn: string, args: SelectableOrExpression<T>[], options?: AggregateOptions<T>, type?: (t: T['columnTypes']) => C): SetQueryReturnsColumnOrThrow<T, C> & C['operators'];
     /**
      * Use `exists()` to check if there is at least one record-matching condition.
      *
@@ -3513,7 +3600,7 @@ declare class AggregateMethods {
      *     // select a column with alias
      *     nameAlias: 'name',
      *     // select raw SQL with alias
-     *     foo: db.table.sql<string>`"bar" || "baz"`,
+     *     foo: sql<string>`"bar" || "baz"`,
      *   },
      *   aggregateOptions,
      * );
@@ -3523,7 +3610,7 @@ declare class AggregateMethods {
      *   object: (q) =>
      *     q.jsonObjectAgg({
      *       nameAlias: 'name',
-     *       foo: db.table.sql<string>`"bar" || "baz"`,
+     *       foo: sql<string>`"bar" || "baz"`,
      *     }),
      * });
      * ```
@@ -3822,7 +3909,7 @@ declare class Create {
      *
      * await db.table.create({
      *   // raw SQL
-     *   column1: db.table.sql`'John' | 'Doe'`,
+     *   column1: sql`'John' || ' ' || 'Doe'`,
      *
      *   // query that returns a single value
      *   // returning multiple values will result in Postgres error
@@ -3877,7 +3964,7 @@ declare class Create {
      * ```ts
      * const oneRecord = await db.table.createRaw({
      *   columns: ['name', 'amount'],
-     *   values: db.table.sql`'name', random()`,
+     *   values: sql`'name', random()`,
      * });
      * ```
      *
@@ -3902,7 +3989,7 @@ declare class Create {
      * ```ts
      * const manyRecords = await db.table.createManyRaw({
      *   columns: ['name', 'amount'],
-     *   values: [db.table.sql`'one', 2`, db.table.sql`'three', 4`],
+     *   values: [sql`'one', 2`, sql`'three', 4`],
      * });
      * ```
      *
@@ -4048,11 +4135,11 @@ declare class Create {
      * // raw SQL expression:
      * db.table
      *   .create(data)
-     *   .onConfict(db.table.sql`(email) where condition`)
+     *   .onConfict(sql`(email) where condition`)
      *   .merge();
      * ```
      *
-     * You can use the db.table.sql function in onConflict.
+     * You can use the `sql` function exported from your `BaseTable` file in onConflict.
      * It can be useful to specify a condition when you have a partial index:
      *
      * ```ts
@@ -4063,7 +4150,7 @@ declare class Create {
      *     active: true,
      *   })
      *   // ignore only when having conflicting email and when active is true.
-     *   .onConflict(db.table.sql`(email) where active`)
+     *   .onConflict(sql`(email) where active`)
      *   .ignore();
      * ```
      *
@@ -4149,7 +4236,7 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
      * db.table
      *   .create(data)
      *   .onConflict()
-     *   .set(db.table.sql`raw SQL expression`);
+     *   .set(sql`raw SQL expression`);
      *
      * // update records only on certain conditions
      * db.table
@@ -4344,7 +4431,6 @@ declare class From {
      * ```ts
      * const value = 123;
      * db.table.fromSql`value = ${value}`;
-     * db.table.fromSql(db.table.sql`value = ${value}`);
      * ```
      *
      * @param args - SQL expression
@@ -4369,16 +4455,20 @@ declare class From {
 
 declare class QueryGet {
     /**
-     * `.get` returns a single value, it will add `LIMIT 1` to the query, and accepts a column name or a raw expression.
-     * It will throw `NotFoundError` when not found.
+     * `.get` returns a single value, adds `LIMIT 1` to the query, and accepts a column name or a raw SQL expression.
+     *
+     * `get` throws a `NotFoundError` when not found, and `getOptional` returns `undefined`.
      *
      * ```ts
      * import { NumberColumn } from 'orchid-orm';
+     * import { sql } from './baseTable';
      *
      * const firstName: string = await db.table.get('name');
      *
-     * const rawResult: number = await db.table.get(
-     *   db.table.sql((t) => t.integer())`1 + 1`,
+     * const rawResult: number = await db.table.get(sql((t) => t.integer())`1 + 1`);
+     *
+     * const firstNameOptional: string | undefined = await db.table.getOptional(
+     *   'name',
      * );
      * ```
      *
@@ -4460,7 +4550,7 @@ declare class Having {
      * Provide SQL expression for the `HAVING` SQL statement:
      *
      * ```ts
-     * db.table.having`count(*) >= ${10}`;
+     * db.table.havingSql`count(*) >= ${10}`;
      * ```
      *
      * @param args - SQL expression
@@ -4906,14 +4996,19 @@ declare class Select {
      *   subQueryResult: Otherdb.table.select('column').take(),
      * });
      *
-     * // select raw SQL value, the first argument of `raw` is a column type, it is used for return type of the query
+     * // select raw SQL value, specify the returning type via <generic> syntax:
      * db.table.select({
-     *   raw: db.table.sql((t) => t.integer())`1 + 2`,
+     *   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 raw value is returned from a callback
      * db.table.select({
-     *   raw: (q) => q.sql((t) => t.integer())`1 + 2`,
+     *   raw: (q) => q.sql`1 + 2`.type((t) => t.integer()),
      * });
      * ```
      *
@@ -5002,7 +5097,7 @@ declare class With {
      *     id: columnTypes.integer(),
      *     name: columnTypes.text(3, 100),
      *   },
-     *   db.table.sql`SELECT id, name FROM "someTable"`,
+     *   sql`SELECT id, name FROM "someTable"`,
      * );
      *
      * // accepts query:
@@ -5010,7 +5105,7 @@ declare class With {
      *
      * // accepts a callback for a query builder:
      * db.table.with('alias', (qb) =>
-     *   qb.select({ one: db.table.sql`1`.type((t) => t.integer()) }),
+     *   qb.select({ one: sql`1`.type((t) => t.integer()) }),
      * );
      *
      * // All mentioned forms can accept options as a second argument:
@@ -5056,7 +5151,7 @@ declare class Union {
      * SomeTable.select('id', 'name').union(
      *   [
      *     OtherTable.select('id', 'name'),
-     *     SomeTable.sql`SELECT id, name FROM "thirdTable"`,
+     *     sql`SELECT id, name FROM "thirdTable"`,
      *   ],
      *   true, // optional wrap parameter
      * );
@@ -5197,7 +5292,7 @@ declare class Update {
      *   column1: 123,
      *
      *   // use raw SQL to update the column
-     *   column2: db.table.sql`2 + 2`,
+     *   column2: sql`2 + 2`,
      *
      *   // use query that returns a single value
      *   // returning multiple values will result in Postgres error
@@ -5320,7 +5415,7 @@ declare class Update {
      * const updatedCount = await db.table.find(1).updateRaw`name = ${value}`;
      *
      * // or update with `sql` function:
-     * await db.table.find(1).updateRaw(db.table.sql`name = ${value}`);
+     * await db.table.find(1).updateRaw(sql`name = ${value}`);
      * ```
      * @param args - raw SQL via a template string or by using a `sql` method
      */
@@ -5893,17 +5988,17 @@ declare class QueryUpsertOrCreate {
     orCreate<T extends UpsertThis, BT extends CreateBelongsToData<T>>(this: T, data: OrCreateArg<T, BT>): UpsertResult<T>;
 }
 
-declare abstract class RawSqlMethods<ColumnTypes> {
+declare class SqlMethod<ColumnTypes> {
     /**
-     * When there is a need to use a piece of raw SQL, use the `sql` method from tables, or a `raw` function imported from `orchid-orm`.
+     * When there is a need to use a piece of raw SQL, use the `sql` exported from the `BaseTable` file, it is also attached to query objects for convenience.
      *
-     * When selecting a raw SQL, specify a resulting type with `<generic>` syntax:
+     * When selecting a custom SQL, specify a resulting type with `<generic>` syntax:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * const result: { num: number }[] = await db.table.select({
-     *   num: db.table.sql<number>`
-     *     random() * 100
-     *   `,
+     *   num: sql<number>`random() * 100`,
      * });
      * ```
      *
@@ -5912,20 +6007,10 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * This example assumes that the `timestamp` column was overridden with `asDate` as shown in [Override column types](/guide/columns-overview#override-column-types).
      *
      * ```ts
-     * const result: { timestamp: Date }[] = await db.table.select({
-     *   timestamp: db.table.sql`now()`.type((t) => t.timestamp()),
-     * });
-     * ```
-     *
-     * Instead of `sql` method, you can use `raw` function from `orchid-orm` (or `pqb`) to do the same.
-     * The only difference, `raw` function don't have access to the overridden column types.
-     *
-     * ```ts
-     * import { raw } from 'orchid-orm';
+     * import { sql } from './baseTable';
      *
      * const result: { timestamp: Date }[] = await db.table.select({
-     *   // if you have overridden timestamp with `asDate` or `asNumber` it won't be parsed properly:
-     *   timestamp: raw`now()`.type((t) => t.timestamp()),
+     *   timestamp: sql`now()`.type((t) => t.timestamp()),
      * });
      * ```
      *
@@ -5941,11 +6026,11 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * const result = await db.$from(subQuery).where({ sum: { gte: 5 } });
      * ```
      *
-     * `where` and other methods don't need the return type, so it can be omitted.
-     * You can pass SQL template directly to the `where`:
+     * Many query methods have a version suffixed with `Sql`, you can pass an SQL template literal directly to these methods.
+     * These methods are: `whereSql`, `whereNotSql`, `orderSql`, `havingSql`, `fromSql`, `findBySql`.
      *
      * ```ts
-     * await db.table.where`"someValue" = random() * 100`;
+     * await db.table.whereSql`"someValue" = random() * 100`;
      * ```
      *
      * Interpolating values in template literals is completely safe:
@@ -5955,48 +6040,48 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * const { value } = req.params;
      *
      * // SQL injection is prevented by a library, this is safe:
-     * await db.table.where`column = ${value}`;
+     * await db.table.whereSql`column = ${value}`;
      * ```
      *
      * In the example above, TS cannot check if the table has `column` column, or if there are joined tables that have such column which will lead to error.
-     * Instead, use the `column` method to reference a column:
+     * Instead, use the [column](/guide/sql-expressions#column) or [ref](/guide/sql-expressions#ref) to reference a column:
      *
      * ```ts
-     * import { raw } from 'orchid-orm';
-     *
      * // ids will be prefixed with proper table names, no ambiguity:
      * db.table.join(db.otherTable, 'id', 'otherId').where`
      *   ${db.table.column('id')} = 1 AND
-     *   ${db.otherTable.column('id')} = 2
+     *   ${db.otherTable.ref('id')} = 2
      * `;
      * ```
      *
      * SQL can be passed with a simple string, it's important to note that this is not safe to interpolate values in it.
      *
      * ```ts
-     * import { raw } from 'orchid-orm';
+     * import { sql } from './baseTable';
      *
      * // no interpolation is okay
-     * await db.table.where(raw({ raw: 'column = random() * 100' }));
+     * await db.table.where(sql({ raw: 'column = random() * 100' }));
      *
      * // get value from user-provided params
      * const { value } = req.params;
      *
      * // this is NOT safe, SQL injection is possible:
-     * await db.table.where(raw({ raw: `column = random() * ${value}` }));
+     * await db.table.where(sql({ raw: `column = random() * ${value}` }));
      * ```
      *
-     * To inject values into `raw` SQL strings, denote it with `$` in the string and provide `values` object.
+     * To inject values into `sql({ raw: '...' })` SQL strings, denote it with `$` in the string and provide `values` object.
      *
-     * Use `$$` to provide column or/and table name (`column` method is more preferable). Column names will be quoted so don't quote them manually.
+     * Use `$$` to provide column or/and table name (`column` or `ref` are preferable). Column names will be quoted so don't quote them manually.
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * // get value from user-provided params
      * const { value } = req.params;
      *
      * // this is SAFE, SQL injection are prevented:
      * await db.table.where(
-     *   db.table.sql({
+     *   sql<boolean>({
      *     raw: '$$column = random() * $value',
      *     values: {
      *       column: 'someTable.someColumn', // or simply 'column'
@@ -6010,45 +6095,41 @@ declare abstract class RawSqlMethods<ColumnTypes> {
      * Summarizing:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * // simplest form:
-     * db.table.sql`key = ${value}`;
+     * sql`key = ${value}`;
      *
      * // with resulting type:
-     * db.table.sql<boolean>`key = ${value}`;
+     * sql<boolean>`key = ${value}`;
      *
      * // with column type for select:
-     * db.table.sql`key = ${value}`.type((t) => t.boolean());
+     * sql`key = ${value}`.type((t) => t.boolean());
      *
      * // with column name via `column` method:
-     * db.table.sql`${db.table.column('column')} = ${value}`;
+     * sql`${db.table.column('column')} = ${value}`;
      *
      * // raw SQL string, not allowed to interpolate values:
-     * db.table.sql({ raw: 'random()' });
+     * sql({ raw: 'random()' });
      *
      * // with resulting type and `raw` string:
-     * db.table.sql<number>({ raw: 'random()' });
+     * sql<number>({ raw: 'random()' });
      *
      * // with column name and a value in a `raw` string:
-     * db.table.sql({
+     * sql({
      *   raw: `$$column = $value`,
      *   values: { column: 'columnName', value: 123 },
      * });
      *
      * // combine template literal, column type, and values:
-     * db.table.sql`($one + $two) / $one`
-     *   .type((t) => t.numeric())
-     *   .values({ one: 1, two: 2 });
+     * sql`($one + $two) / $one`.type((t) => t.numeric()).values({ one: 1, two: 2 });
      * ```
      *
      * @param args - template literal or an object { raw: string }
      * @return object that has `type` and `values` methods
      */
-    sql<T = unknown>(this: {
-        columnTypes: ColumnTypes;
-    }, ...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
-    sql<T = unknown>(this: {
-        columnTypes: ColumnTypes;
-    }, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T = unknown>(this: PickQueryColumnTypes, ...args: StaticSQLArgs): RawSQL<QueryColumn<T>, ColumnTypes>;
+    sql<T = unknown>(this: PickQueryColumnTypes, ...args: [DynamicSQLArg]): DynamicRawSQL<QueryColumn<T>, ColumnTypes>;
 }
 
 type QueryTransformFn<T extends Query> = (input: T['then'] extends QueryThen<infer Data> ? Data : never) => unknown;
@@ -6155,24 +6236,6 @@ type NarrowTypeResult<T extends PickQueryMetaResultReturnType, Narrow> = {
         [P in keyof T['result'][K]]: P extends 'outputType' ? Narrow[K] extends T['result'][K]['outputType'] ? Narrow[K] : `narrowType() error: passed type does not exist in '${K & string}'s type union` : T['result'][K][P];
     } : T['result'][K];
 };
-declare class ColumnRefExpression<T extends QueryColumn> extends Expression<T> {
-    name: string;
-    result: {
-        value: T;
-    };
-    q: ExpressionData;
-    constructor(value: T, name: string);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
-declare class RefExpression<T extends QueryColumn> extends Expression<T> {
-    q: QueryData;
-    ref: string;
-    result: {
-        value: T;
-    };
-    constructor(value: T, q: QueryData, ref: string);
-    makeSQL(ctx: ToSQLCtx, quotedAs?: string): string;
-}
 type WrapQueryArg = FromQuerySelf;
 declare const _queryAll: <T extends Query>(q: T) => SetQueryReturnsAll<T>;
 declare const _queryTake: <T extends PickQueryResult>(q: T) => SetQueryReturnsOne<T>;
@@ -6181,7 +6244,7 @@ declare const _queryExec: <T extends Query>(q: T) => never;
 declare const _queryFindBy: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArg<T>[]) => SetQueryReturnsOne<WhereResult<T>>;
 declare const _queryFindByOptional: <T extends QueryBase<EmptyObject>>(q: T, args: WhereArg<T>[]) => SetQueryReturnsOneOptional<WhereResult<T>>;
 declare const _queryRows: <T extends Query>(q: T) => SetQueryReturnsRows<T>;
-interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, From, Join, With, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawSqlMethods<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods {
+interface QueryMethods<ColumnTypes> extends AsMethods, AggregateMethods, Select, From, Join, With, Union, JsonModifiers, JsonMethods, Create, Update, Delete, Transaction, For, Where, SearchMethods, Clear, Having, QueryLog, QueryHooks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, SqlMethod<ColumnTypes>, TransformMethods, ScopeMethods, SoftDeleteMethods, ExpressionMethods {
 }
 declare class QueryMethods<ColumnTypes> {
     /**
@@ -6282,11 +6345,13 @@ declare class QueryMethods<ColumnTypes> {
      * db.table.distinct().select('name');
      * ```
      *
-     * Can accept column names or raw expressions to place it to `DISTINCT ON (...)`:
+     * Can accept column names or raw SQL expressions to place it to `DISTINCT ON (...)`:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * // Distinct on the name and raw SQL
-     * db.table.distinct('name', db.table.sql`raw sql`).select('id', 'name');
+     * db.table.distinct('name', sql`raw sql`).select('id', 'name');
      * ```
      *
      * @param columns - column names or a raw SQL
@@ -6404,9 +6469,11 @@ declare class QueryMethods<ColumnTypes> {
      * Also, it's possible to group by a selected value:
      *
      * ```ts
+     * import { sql } from './baseTable';
+     *
      * const results = db.product
      *   .select({
-     *     month: db.product.sql`extract(month from "createdAt")`.type((t) =>
+     *     month: sql`extract(month from "createdAt")`.type((t) =>
      *       // month is returned as string, parse it to int
      *       t.string().parse(parseInt),
      *     ),
@@ -6490,8 +6557,6 @@ declare class QueryMethods<ColumnTypes> {
      *
      * ```ts
      * db.table.orderSql`raw sql`;
-     * // or
-     * db.table.orderSql(db.table.sql`raw sql`);
      * ```
      *
      * @param args - SQL expression
@@ -6653,50 +6718,6 @@ declare class QueryMethods<ColumnTypes> {
      * @param fn - helper function
      */
     makeHelper<T extends PickQueryMetaShape, Args extends unknown[], Result>(this: T, fn: (q: T, ...args: Args) => Result): QueryHelper<T, Args, Result>;
-    /**
-     * `column` references a table column, this can be used in raw SQL or when building a column expression.
-     * Only for referencing a column in the query's table. For referencing joined table's columns, see [ref](#ref).
-     *
-     * ```ts
-     * await db.table.select({
-     *   // select `("table"."id" = 1 OR "table"."name" = 'name') AS "one"`,
-     *   // returns a boolean
-     *   one: (q) =>
-     *     q.sql<boolean>`${q.column('id')} = ${1} OR ${q.column('name')} = ${'name'}`,
-     *
-     *   // selects the same as above, but by building a query
-     *   two: (q) => q.column('id').equals(1).or(q.column('name').equals('name')),
-     * });
-     * ```
-     *
-     * @param name - column name
-     */
-    column<T extends PickQueryShape, K extends keyof T['shape']>(this: T, name: K): ColumnRefExpression<T['shape'][K]> & T['shape'][K]['operators'];
-    /**
-     * `ref` is similar to [column](#column), but it also allows to reference a column of joined table,
-     * and other dynamically defined columns.
-     *
-     * ```ts
-     * await db.table.join('otherTable').select({
-     *   // select `("otherTable"."id" = 1 OR "otherTable"."name" = 'name') AS "one"`,
-     *   // returns a boolean
-     *   one: (q) =>
-     *     q.sql<boolean>`${q.ref('otherTable.id')} = ${1} OR ${q.ref(
-     *       'otherTable.name',
-     *     )} = ${'name'}`,
-     *
-     *   // selects the same as above, but by building a query
-     *   two: (q) =>
-     *     q
-     *       .ref('otherTable.id')
-     *       .equals(1)
-     *       .or(q.ref('otherTable.name').equals('name')),
-     * });
-     * ```
-     *
-     * @param arg - any available column name, such as of a joined table
-     */
-    ref<T extends PickQueryMeta, K extends keyof T['meta']['selectable'] & string>(this: T, arg: K): RefExpression<T['meta']['selectable'][K]['column']> & T['meta']['selectable'][K]['column']['operators'];
     /**
      * Narrows a part of the query output type.
      * Use with caution, type-safety isn't guaranteed with it.
@@ -6823,9 +6844,11 @@ interface PickQueryMetaResultRelations extends PickQueryResult, PickQueryMeta, P
 }
 interface PickQueryMetaResultRelationsWindows extends PickQueryMetaResultRelations, PickQueryWindows {
 }
-interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows {
+interface PickQueryColumnTypes {
     columnTypes: unknown;
 }
+interface PickQueryMetaResultRelationsWindowsColumnTypes extends PickQueryMetaResultRelationsWindows, PickQueryColumnTypes {
+}
 interface PickQueryMetaTable extends PickQueryMeta, PickQueryTable {
 }
 interface PickQueryMetaTableShape extends PickQueryMetaTable, PickQueryShape {
@@ -7008,6 +7031,12 @@ type SetQueryWith<T, WithData> = {
 type AddQueryWith<T extends PickQueryWithData, With extends WithDataItem> = SetQueryWith<T, {
     [K in keyof T['withData'] | With['table']]: K extends With['table'] ? With : K extends keyof T['withData'] ? T['withData'][K] : never;
 }>;
+interface QueryOrExpression<T> {
+    result: {
+        value: QueryColumn<T>;
+    };
+}
+type QueryOrExpressionBooleanOrNullResult = QueryOrExpression<boolean | null>;
 
 interface ColumnData extends ColumnDataBase {
     maxChars?: number;
@@ -7670,4 +7699,4 @@ type CopyResult<T extends PickQueryMeta> = SetQueryKind<T, 'copy'>;
  */
 declare function copyTableData<T extends PickQueryMetaShape>(query: T, arg: CopyArg<T>): CopyResult<T>;
 
-export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateBelongsToData, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbDomainArg, DbDomainArgRecord, DbExtension, DbOptions, DbResult, DbSharedOptions, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, From, FromArg, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictMerge, OnConflictQueryBuilder, OnConflictSet, OnConflictTarget, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RawSqlMethods, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryKindResult, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsAllKindResult, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnKindResult, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneKindResult, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsPluckColumnKindResult, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, SetQueryWith, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };
+export { Adapter, AdapterConfig, AdapterOptions, AddQueryDefaults, AddQuerySelect, AddQueryWith, AfterHook, AggregateMethods, AggregateOptions, AliasOrTable, ArrayColumn, ArrayColumnValue, ArrayData, AsMethods, AsQueryArg, BaseOperators, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanQueryColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ClearStatement, CloneSelfKeys, ColumnData, ColumnExpression, ColumnFromDbParams, ColumnInfoQueryData, ColumnOperators, ColumnRefExpression, ColumnType, ColumnsByType, ColumnsShape, ColumnsShapeToNullableObject, ColumnsShapeToObject, ColumnsShapeToObjectArray, ColumnsShapeToPluck, CommonQueryData, ComputedColumnsBase, CopyOptions, CopyQueryData, Create, CreateBelongsToData, CreateColumn, CreateCtx, CreateData, CreateKind, CreateMethodsNames, CreateRelationsData, CreateRelationsDataOmittingFKeys, CreateSelf, CustomTypeColumn, DateBaseColumn, DateColumn, DateColumnInput, DateTimeBaseClass, DateTimeTzBaseClass, Db, DbDomainArg, DbDomainArgRecord, DbExtension, DbOptions, DbResult, DbSharedOptions, DbTableConstructor, DbTableOptionScopes, DbTableOptions, DecimalColumn, DecimalColumnData, DefaultColumnTypes, DefaultSchemaConfig, Delete, DeleteArgs, DeleteMethodsNames, DeleteQueryData, DeleteResult, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionMethods, ExpressionOutput, FnExpression, FnExpressionArgs, FnExpressionArgsPairs, FnExpressionArgsValue, For, From, FromArg, FromQuerySelf, FromResult, GetArg, GetColumnInfo, GetQueryResult, GetResult, GetResultOptional, GetStringArg, GroupArg, Having, HavingItem, HookAction, HookSelect, IdentityColumn, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, IsolationLevel, JSONColumn, JSONTextColumn, Join, JoinArgs, JoinCallback, JoinFirstArg, JoinItem, JoinItemArgs, JoinLateralCallback, JoinLateralItem, JoinLateralResult, JoinOverrides, JoinQueryBuilder, JoinQueryMethod, JoinResult, JoinedParsers, JoinedShapes, JsonItem, JsonMethods, JsonModifiers, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MapTableScopesOption, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumnData, OnConflictMerge, OnConflictQueryBuilder, OnConflictSet, OnConflictTarget, OnMethods, Operator, Operators, OperatorsAny, OperatorsArray, OperatorsBoolean, OperatorsDate, OperatorsJson, OperatorsNumber, OperatorsText, OperatorsTime, OrCreateArg, OrExpression, OrchidOrmError, OrchidOrmInternalError, OrderArg, OrderArgSelf, OrderArgs, OrderItem, OrderTsQueryConfig, Over, PathColumn, PickColumnData, PickQueryBaseQuery, PickQueryColumnTypes, PickQueryDataShapeAndJoinedShapes, PickQueryInternal, PickQueryMetaRelations, PickQueryMetaResultRelations, PickQueryMetaResultRelationsWindows, PickQueryMetaResultRelationsWindowsColumnTypes, PickQueryMetaResultRelationsWithDataReturnType, PickQueryMetaResultRelationsWithDataReturnTypeShape, PickQueryMetaResultReturnTypeWithDataWindows, PickQueryMetaResultReturnTypeWithDataWindowsTable, PickQueryMetaShapeRelationsWithData, PickQueryMetaTable, PickQueryMetaTableShape, PickQueryMetaTableShapeReturnTypeWithData, PickQueryMetaWithData, PickQueryQ, PickQueryQAndBaseQuery, PickQueryQAndInternal, PickQueryRelations, PickQueryRelationsWithData, PickQueryShapeResultSinglePrimaryKey, PickQueryShapeSinglePrimaryKey, PickQuerySinglePrimaryKey, PickQueryWindows, PickQueryWithData, PointColumn, PolygonColumn, Query, QueryAfterHook, QueryArraysResult, QueryBase, QueryBaseThen, QueryBeforeHook, QueryData, QueryDataFromItem, QueryDataJoinTo, QueryDefaultReturnData, QueryError, QueryErrorName, QueryGet, QueryGetSelf, QueryHelperResult, QueryHookSelect, QueryHooks, QueryInternal, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMetaHasSelect, QueryMetaHasWhere, QueryMethods, QueryOrExpression, QueryOrExpressionBooleanOrNullResult, QueryResult, QueryReturnsAll, QueryScopeData, QueryScopes, QuerySourceItem, QueryTransform, QueryTransformFn, QueryUpsertOrCreate, QueryWithComputed, QueryWithTable, RawSQL, RealColumn, RecordOfColumnsShapeBase, RefExpression, RelationConfigBase, RelationConfigDataForCreate, RelationJoinQuery, RelationQuery, RelationQueryBase, RelationsBase, SearchArg, SearchMethods, SearchWeight, SearchWeightRecord, Select, SelectArg, SelectAs, SelectItem, SelectQueryData, SelectSubQueryResult, SelectableFromShape, SelectableOfType, SelectableOrExpression, SelectableOrExpressionOfType, SerialColumn, SerialColumnData, SetQueryKind, SetQueryKindResult, SetQueryReturnsAll, SetQueryReturnsAllKind, SetQueryReturnsAllKindResult, SetQueryReturnsColumnInfo, SetQueryReturnsColumnKind, SetQueryReturnsColumnKindResult, SetQueryReturnsColumnOptional, SetQueryReturnsColumnOrThrow, SetQueryReturnsOne, SetQueryReturnsOneKind, SetQueryReturnsOneKindResult, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsPluckColumn, SetQueryReturnsPluckColumnKind, SetQueryReturnsPluckColumnKindResult, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValueOptional, SetQueryReturnsValueOrThrow, SetQueryReturnsVoid, SetQueryReturnsVoidKind, SetQueryTableAlias, SetQueryWith, ShapeColumnPrimaryKeys, ShapeUniqueColumns, SimpleJoinItem, SimpleJoinItemNonSubQueryArgs, SmallIntColumn, SmallSerialColumn, SortDir, SqlFn, SqlMethod, StringColumn$1 as StringColumn, TableData, TableDataFn, TableDataInput, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TableDataMethods, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimestampColumn, TimestampTZColumn, ToSQLCtx, ToSQLOptions, ToSQLQuery, Transaction, TransactionAdapter, TransactionOptions, TransformMethods, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, UniqueConstraints, UniqueQueryTypeOrExpression, UniqueTableDataItem, UnknownColumn, Update, UpdateArg, UpdateCtx, UpdateCtxCollect, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdateSelf, UpdatedAtDataInjector, UpsertArg, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereArgs, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereNotArgs, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WhereSearchItem, WhereSearchResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowItem, With, WithDataBase, WithDataItem, WithDataItems, WithItem, WithOptions, WrapQueryArg, XMLColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryAs, _queryChangeCounter, _queryCreate, _queryCreateFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateManyRaw, _queryCreateRaw, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertManyRaw, _queryInsertRaw, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpdateRaw, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotSql, _queryWhereSql, addComputedColumns, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, checkIfASimpleQuery, cloneQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDb, defaultSchemaConfig, extendQuery, foreignKeyArgumentToCode, getClonedQueryData, getColumnInfo, getColumnTypes, getPrimaryKeys, getQueryAs, getShapeFromSelect, handleResult, identityToCode, indexInnerToCode, indexToCode, instantiateColumn, isDefaultTimeStamp, isQueryReturnsAll, isSelectingCount, joinSubQuery, logColors, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, makeRegexToFindInSql, makeSQL, parseRecord, parseResult, parseTableData, parseTableDataInput, primaryKeyInnerToCode, processSelectArg, pushLimitSQL, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quote, quoteString, raw, referencesArgsToCode, resolveSubQueryCallback, saveSearchAlias, setParserForSelectedString, setQueryObjectValue, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfNoWhere, toSQL, toSQLCacheKey };