pqb 0.10.1 → 0.10.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as orchid_core from 'orchid-core';
-import { EmptyObject, QueryResultRow, AdapterBase, QueryInput, ColumnsShapeBase, RawExpression, ColumnTypeBase, MaybeArray, StringKey, ColumnOutput, SimpleSpread, FilterTuple, NullableColumn, QueryMetaBase, ColumnTypesBase, DbBase, ThenResult, ColumnShapeOutput, DefaultSelectColumns, SetOptional, Spread, CoalesceString, QueryBaseCommon, QueryCommon, ColumnDataBase, BaseOperators, PrimaryKeyColumn, HiddenColumn, ColumnWithDefault, ValidationContext, BaseNumberData, Code, numberTypeMethods, BaseStringData, DateColumnData, dateTypeMethods, JSONTypeAny, record, arrayMethods, name } from 'orchid-core';
+import { EmptyObject, RawExpression, ColumnTypeBase, MaybeArray, QueryResultRow, AdapterBase, QueryInput, ColumnsShapeBase, StringKey, ColumnOutput, SimpleSpread, FilterTuple, NullableColumn, QueryInternal, QueryMetaBase, ColumnTypesBase, DbBase, ThenResult, ColumnShapeOutput, DefaultSelectColumns, SetOptional, Spread, CoalesceString, QueryBaseCommon, QueryCommon, ColumnDataBase, BaseOperators, PrimaryKeyColumn, HiddenColumn, ValidationContext, BaseNumberData, Code, numberTypeMethods, BaseStringData, DateColumnData, dateTypeMethods, JSONTypeAny, record, arrayMethods, name } from 'orchid-core';
 import { PoolConfig, Pool, PoolClient } from 'pg';
 
 declare type BaseRelation = {
@@ -87,6 +87,168 @@ declare type RelationQuery<Name extends PropertyKey = string, Params extends Rec
     [K in DeleteMethodsNames]: never;
 })> = ((params: Params) => Q) & Q;
 
+declare type Sql = {
+    text: string;
+    values: unknown[];
+};
+declare const checkIfASimpleQuery: (q: Query) => boolean;
+declare type WithItem = [
+    as: string,
+    options: WithOptions,
+    query: Query | RawExpression
+];
+declare type WithOptions = {
+    columns?: string[];
+    recursive?: true;
+    materialized?: true;
+    notMaterialized?: true;
+};
+declare type JsonItem<As extends string = string, Type extends ColumnTypeBase = ColumnTypeBase> = {
+    __json: [
+        kind: 'set',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            createIfMissing?: boolean;
+        }
+    ] | [
+        kind: 'insert',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+            insertAfter?: boolean;
+        }
+    ] | [
+        kind: 'remove',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>
+    ] | [
+        kind: 'pathQuery',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: string,
+        options?: {
+            vars?: string;
+            silent?: boolean;
+        }
+    ];
+};
+declare type SelectItem = string | RelationQuery | AggregateItem | {
+    selectAs: Record<string, string | Query | RawExpression>;
+} | SelectFunctionItem | JsonItem | RawExpression;
+declare type SelectFunctionItem = {
+    function: string;
+    arguments: SelectItem[];
+    as?: string;
+};
+declare type JoinItem = {
+    type: string;
+    args: [relation: string] | [
+        arg: string | QueryWithTable,
+        conditions: Record<string, string | RawExpression> | RawExpression | ((q: unknown) => QueryBase) | true
+    ] | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        rightColumn: string | RawExpression
+    ] | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        op: string,
+        rightColumn: string | RawExpression
+    ];
+    isSubQuery: boolean;
+};
+declare type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | RawExpression> | RawExpression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
+    NOT?: MaybeArray<WhereItem>;
+    AND?: MaybeArray<WhereItem>;
+    OR?: MaybeArray<WhereItem>[];
+    IN?: MaybeArray<WhereInItem>;
+    EXISTS?: MaybeArray<JoinItem['args']>;
+    ON?: WhereOnItem | WhereJsonPathEqualsItem;
+}) | ((q: unknown) => QueryBase) | Query | RawExpression;
+declare type WhereInItem = {
+    columns: string[];
+    values: unknown[][] | Query | RawExpression;
+};
+declare type WhereJsonPathEqualsItem = [
+    leftColumn: string,
+    leftPath: string,
+    rightColumn: string,
+    rightPath: string
+];
+declare type WhereOnItem = {
+    joinFrom: WhereOnJoinItem;
+    joinTo: WhereOnJoinItem;
+    on: [leftFullColumn: string, rightFullColumn: string] | [leftFullColumn: string, op: string, rightFullColumn: string];
+};
+declare type WhereOnJoinItem = {
+    table?: string;
+    query: {
+        as?: string;
+    };
+} | string;
+declare type AggregateItemOptions = {
+    as?: string;
+    distinct?: boolean;
+    order?: OrderItem[];
+    filter?: WhereItem;
+    filterOr?: WhereItem[];
+    withinGroup?: boolean;
+    over?: string;
+    window?: WindowItem;
+};
+declare type SortDir = 'ASC' | 'DESC';
+declare type OrderItem = string | Record<string, SortDir | {
+    dir: SortDir;
+    nulls: 'FIRST' | 'LAST';
+}> | RawExpression;
+declare type AggregateItemArg = Expression | Record<string, Expression> | [Expression, string];
+declare type AggregateItem = {
+    function: string;
+    arg?: AggregateItemArg;
+    options: AggregateItemOptions;
+};
+declare type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
+    [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['type'];
+};
+declare type HavingItemObject = Record<string, unknown>;
+declare type HavingItem = Record<string, HavingItemObject> | {
+    count?: number | HavingItemObject;
+} | Query | RawExpression;
+declare type WindowItem = Record<string, WindowDeclaration | RawExpression>;
+declare type WindowDeclaration = {
+    partitionBy?: Expression | Expression[];
+    order?: OrderItem;
+};
+declare type UnionItem = Query | RawExpression;
+declare type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
+declare type OnConflictItem = string | string[] | RawExpression;
+declare type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
+
+declare type ToSqlCtx = {
+    whereQueryBuilder: typeof WhereQueryBuilder;
+    onQueryBuilder: typeof OnQueryBuilder;
+    sql: string[];
+    values: unknown[];
+};
+declare type toSqlCacheKey = typeof toSqlCacheKey;
+declare const toSqlCacheKey: unique symbol;
+declare type ToSqlOptions = {
+    clearCache?: boolean;
+    values?: unknown[];
+};
+declare const toSql: (table: Query, options?: ToSqlOptions) => Sql;
+declare const makeSql: (table: Query, { values }?: ToSqlOptions) => Sql;
+
 declare type TypeParsers = Record<number, (input: string) => unknown>;
 declare type QueryResult<T extends QueryResultRow = any> = {
     rowCount: number;
@@ -137,6 +299,8 @@ declare type CommonQueryData = {
     throwOnNotFound?: boolean;
     with?: WithItem[];
     withShapes?: Record<string, ColumnsShape>;
+    joinedShapes?: Record<string, ColumnsShapeBase>;
+    joinedParsers?: Record<string, ColumnsParsers>;
     schema?: string;
     select?: SelectItem[];
     as?: string;
@@ -159,8 +323,6 @@ declare type SelectQueryData = CommonQueryData & {
     distinct?: Expression[];
     fromOnly?: boolean;
     join?: JoinItem[];
-    joinedShapes?: Record<string, ColumnsShapeBase>;
-    joinedParsers?: Record<string, ColumnsParsers>;
     group?: (string | RawExpression)[];
     having?: HavingItem[];
     havingOr?: HavingItem[][];
@@ -187,8 +349,6 @@ declare type InsertQueryData = CommonQueryData & {
     fromQuery?: Query;
     using?: JoinItem[];
     join?: JoinItem[];
-    joinedShapes?: Record<string, ColumnsShapeBase>;
-    joinedParsers?: Record<string, ColumnsParsers>;
     onConflict?: {
         type: 'ignore';
         expr?: OnConflictItem;
@@ -215,8 +375,6 @@ declare type UpdateQueryData = CommonQueryData & {
 declare type DeleteQueryData = CommonQueryData & {
     type: 'delete';
     join?: JoinItem[];
-    joinedShapes?: Record<string, ColumnsShapeBase>;
-    joinedParsers?: Record<string, ColumnsParsers>;
     beforeDelete?: BeforeCallback[];
     afterDelete?: AfterCallback[];
 };
@@ -258,167 +416,6 @@ declare type CopyOptions<Column = string> = {
 declare type QueryData = SelectQueryData | InsertQueryData | UpdateQueryData | DeleteQueryData | TruncateQueryData | ColumnInfoQueryData | CopyQueryData;
 declare const cloneQueryArrays: (q: QueryData) => void;
 
-declare type Sql = {
-    text: string;
-    values: unknown[];
-};
-declare const checkIfASimpleQuery: (q: QueryData) => boolean;
-declare type WithItem = [
-    as: string,
-    options: WithOptions,
-    query: Query | RawExpression
-];
-declare type WithOptions = {
-    columns?: string[];
-    recursive?: true;
-    materialized?: true;
-    notMaterialized?: true;
-};
-declare type JsonItem<As extends string = string, Type extends ColumnTypeBase = ColumnTypeBase> = {
-    __json: [
-        kind: 'set',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>,
-        value: unknown,
-        options?: {
-            createIfMissing?: boolean;
-        }
-    ] | [
-        kind: 'insert',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>,
-        value: unknown,
-        options?: {
-            insertAfter?: boolean;
-        }
-    ] | [
-        kind: 'remove',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: Array<string | number>
-    ] | [
-        kind: 'pathQuery',
-        as: As,
-        type: Type,
-        column: string | JsonItem,
-        path: string,
-        options?: {
-            vars?: string;
-            silent?: boolean;
-        }
-    ];
-};
-declare type SelectItem = string | RelationQuery | AggregateItem | {
-    selectAs: Record<string, string | Query | RawExpression>;
-} | SelectFunctionItem | JsonItem | RawExpression;
-declare type SelectFunctionItem = {
-    function: string;
-    arguments: SelectItem[];
-    as?: string;
-};
-declare type JoinItem = {
-    type: string;
-    args: [relation: string] | [
-        arg: string | QueryWithTable,
-        conditions: Record<string, string | RawExpression> | RawExpression | ((q: unknown) => QueryBase) | true
-    ] | [
-        arg: string | QueryWithTable,
-        leftColumn: string | RawExpression,
-        rightColumn: string | RawExpression
-    ] | [
-        arg: string | QueryWithTable,
-        leftColumn: string | RawExpression,
-        op: string,
-        rightColumn: string | RawExpression
-    ];
-};
-declare type WhereItem = (Omit<Record<string, unknown | Record<string, unknown | Query | RawExpression> | RawExpression>, 'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'> & {
-    NOT?: MaybeArray<WhereItem>;
-    AND?: MaybeArray<WhereItem>;
-    OR?: MaybeArray<WhereItem>[];
-    IN?: MaybeArray<WhereInItem>;
-    EXISTS?: MaybeArray<JoinItem['args']>;
-    ON?: WhereOnItem | WhereJsonPathEqualsItem;
-}) | ((q: unknown) => QueryBase) | Query | RawExpression;
-declare type WhereInItem = {
-    columns: string[];
-    values: unknown[][] | Query | RawExpression;
-};
-declare type WhereJsonPathEqualsItem = [
-    leftColumn: string,
-    leftPath: string,
-    rightColumn: string,
-    rightPath: string
-];
-declare type WhereOnItem = {
-    joinFrom: WhereOnJoinItem;
-    joinTo: WhereOnJoinItem;
-    on: [leftFullColumn: string, rightFullColumn: string] | [leftFullColumn: string, op: string, rightFullColumn: string];
-};
-declare type WhereOnJoinItem = {
-    table?: string;
-    query: {
-        as?: string;
-    };
-} | string;
-declare type AggregateItemOptions = {
-    as?: string;
-    distinct?: boolean;
-    order?: OrderItem[];
-    filter?: WhereItem;
-    filterOr?: WhereItem[];
-    withinGroup?: boolean;
-    over?: string;
-    window?: WindowItem;
-};
-declare type SortDir = 'ASC' | 'DESC';
-declare type OrderItem = string | Record<string, SortDir | {
-    dir: SortDir;
-    nulls: 'FIRST' | 'LAST';
-}> | RawExpression;
-declare type AggregateItemArg = Expression | Record<string, Expression> | [Expression, string];
-declare type AggregateItem = {
-    function: string;
-    arg?: AggregateItemArg;
-    options: AggregateItemOptions;
-};
-declare type ColumnOperators<S extends SelectableBase, Column extends keyof S> = {
-    [O in keyof S[Column]['column']['operators']]?: S[Column]['column']['operators'][O]['type'];
-};
-declare type HavingItemObject = Record<string, unknown>;
-declare type HavingItem = Record<string, HavingItemObject> | {
-    count?: number | HavingItemObject;
-} | Query | RawExpression;
-declare type WindowItem = Record<string, WindowDeclaration | RawExpression>;
-declare type WindowDeclaration = {
-    partitionBy?: Expression | Expression[];
-    order?: OrderItem;
-};
-declare type UnionItem = Query | RawExpression;
-declare type UnionKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'INTERSECT ALL' | 'EXCEPT' | 'EXCEPT ALL';
-declare type OnConflictItem = string | string[] | RawExpression;
-declare type OnConflictMergeUpdate = string | string[] | Record<string, unknown> | RawExpression;
-
-declare type ToSqlCtx = {
-    whereQueryBuilder: typeof WhereQueryBuilder;
-    onQueryBuilder: typeof OnQueryBuilder;
-    sql: string[];
-    values: unknown[];
-};
-declare type toSqlCacheKey = typeof toSqlCacheKey;
-declare const toSqlCacheKey: unique symbol;
-declare type ToSqlOptions = {
-    clearCache?: boolean;
-    values?: unknown[];
-};
-declare const toSql: (table: Query, options?: ToSqlOptions) => Sql;
-declare const makeSql: (table: Query, { values }?: ToSqlOptions) => Sql;
-
 declare const getClonedQueryData: (query: QueryData) => QueryData;
 declare const getQueryAs: (q: {
     table?: string;
@@ -473,10 +470,10 @@ declare type SelectSubQueryResult<Arg extends Query & {
     [isRequiredRelationKey]?: boolean;
 }> = QueryReturnsAll<Arg['returnType']> extends true ? ArrayOfColumnsObjects<Arg['result']> : Arg['returnType'] extends 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? PluckResultColumnType<Arg['result']['pluck']> : Arg[isRequiredRelationKey] extends true ? ColumnsObject<Arg['result']> : NullableColumn<ColumnsObject<Arg['result']>>;
 declare const addParserForRawExpression: (q: Query, key: string | getValueKey, raw: RawExpression) => void;
-declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, arg: RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Exclude<keyof T["selectable"], number | symbol> | ((q: T) => Query)) => string | RawExpression | Query;
+declare const addParserForSelectItem: <T extends Query>(q: T, as: string | getValueKey | undefined, key: string, arg: RawExpression<ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Exclude<keyof T["selectable"], number | symbol> | ((q: T) => Query)) => string | RawExpression | Query;
 declare const addParserToQuery: (query: QueryData, key: string | getValueKey, parser: ColumnParser) => void;
 declare const processSelectArg: <T extends Query>(q: T, as: string | undefined, arg: SelectArg<T>, columnAs?: string | getValueKey) => SelectItem;
-declare const getShapeFromSelect: (q: Query) => ColumnsShapeBase;
+declare const getShapeFromSelect: (q: Query, isSubQuery?: boolean) => ColumnsShapeBase;
 declare class Select {
     select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
     _select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
@@ -501,7 +498,12 @@ declare type SetFromSelectable<T extends Query, Arg extends Query> = Omit<T, 'se
 declare type MergeFromResult<T extends Query, Arg extends Query> = AddQuerySelect<Omit<T, 'result'> & {
     result: Pick<T['result'], keyof Arg['result']>;
 }, Arg['result']>;
-declare type FromResult<T extends Query, Args extends FromArgs<T>> = Args[0] extends string ? SetQueryTableAlias<T, Args[0]> : Args[0] extends Query ? SetQueryTableAlias<MergeFromResult<SetFromSelectable<T, Args[0]>, Args[0]>, AliasOrTable<Args[0]>> : T;
+declare type FromResult<T extends Query, Args extends FromArgs<T>, Arg = Args[0]> = Arg extends string ? T['withData'] extends Record<string, WithDataItem> ? Arg extends keyof T['withData'] ? Omit<T, 'meta' | 'selectable'> & {
+    meta: Omit<T['meta'], 'as'> & {
+        as?: string;
+    };
+    selectable: SelectableFromShape<T['withData'][Arg]['shape'], Arg>;
+} : SetQueryTableAlias<T, Arg> : SetQueryTableAlias<T, Arg> : Arg extends Query ? SetQueryTableAlias<MergeFromResult<SetFromSelectable<T, Arg>, Arg>, AliasOrTable<Arg>> : T;
 declare class From {
     from<T extends Query, Args extends FromArgs<T>>(this: T, ...args: Args): FromResult<T, Args>;
     _from<T extends Query, Args extends FromArgs<T>>(this: T, ...args: Args): FromResult<T, Args>;
@@ -516,7 +518,7 @@ declare type WhereArg<T extends QueryBase> = (Omit<{
         columns: (keyof T['selectable'])[];
         values: unknown[][] | Query | RawExpression;
     }>;
-    EXISTS?: MaybeArray<JoinArgs<T> | JoinCallbackArg<T>>;
+    EXISTS?: MaybeArray<JoinArgs<T> | [JoinCallbackArg<T>, JoinCallback<T, JoinCallbackArg<T>>]>;
 }) | QueryBase | RawExpression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
 declare type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
 declare type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | RawExpression : ({
@@ -546,6 +548,7 @@ declare abstract class Where implements QueryBase {
     abstract relations: RelationsBase;
     abstract withData: WithDataBase;
     abstract baseQuery: Query;
+    abstract internal: QueryInternal;
     query: QueryData;
     table?: string;
     meta: QueryMetaBase;
@@ -600,6 +603,7 @@ declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where i
     relations: Q['relations'];
     baseQuery: Query;
     withData: {};
+    internal: {};
     constructor(q: QueryBase | string, shape: ColumnsShapeBase);
     clone<T extends this>(this: T): T;
 }
@@ -651,6 +655,7 @@ declare type JoinCallback<T extends QueryBase, Arg extends JoinCallbackArg<T>> =
     relations: RelationsBase;
     withData: WithDataBase;
     meta: EmptyObject;
+    internal: QueryInternal;
 } : never : Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['table'] : never : never>) => OnQueryBuilder;
 declare type JoinCallbackResult<T extends Query, Arg extends JoinCallbackArg<T>> = AddQueryJoinedTable<T, Arg extends Query ? Arg : T['relations'] extends Record<string, Relation> ? Arg extends keyof T['relations'] ? T['relations'][Arg]['table'] : Arg extends keyof T['withData'] ? T['withData'][Arg] extends WithDataItem ? {
     table: T['withData'][Arg]['table'];
@@ -696,7 +701,7 @@ declare type OnArgs<Q extends {
 ];
 declare const pushQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase | string, joinTo: QueryBase | string, ...on: OnArgs<QueryBase>) => T;
 declare const pushQueryOrOn: typeof pushQueryOn;
-declare const addQueryOn: typeof pushQueryOrOn;
+declare const addQueryOn: <T extends QueryBase>(q: T, joinFrom: QueryBase, joinTo: QueryBase, ...args: OnArgs<QueryBase>) => T;
 declare const addQueryOrOn: typeof pushQueryOrOn;
 declare type OnJsonPathEqualsArgs<T extends QueryBase> = [
     leftColumn: keyof T['selectable'],
@@ -704,8 +709,8 @@ declare type OnJsonPathEqualsArgs<T extends QueryBase> = [
     rightColumn: keyof T['selectable'],
     rightPath: string
 ];
-declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBase = QueryBase> extends WhereQueryBuilder<Omit<J, 'selectable'> & {
-    selectable: Omit<S['selectable'], keyof S['shape']> & J['selectable'];
+declare class OnQueryBuilder<S extends QueryBase = QueryBase, J extends QueryBase = QueryBase> extends WhereQueryBuilder<J & {
+    selectable: Omit<S['selectable'], keyof S['shape']>;
 }> implements QueryBase {
     joinTo: QueryBase;
     constructor(q: QueryBase | string, shape: ColumnsShapeBase, joinTo: QueryBase);
@@ -755,9 +760,9 @@ declare class NotFoundError extends PormError {
 }
 declare class MoreThanOneRowError extends PormError {
 }
-declare class PormInternalError extends Error {
+declare class OrchidInternalError extends Error {
 }
-declare class UnhandledTypeError extends PormInternalError {
+declare class UnhandledTypeError extends OrchidInternalError {
     constructor(value: never);
 }
 
@@ -768,6 +773,7 @@ declare type DbOptions<CT extends ColumnTypesBase> = ({
     columnTypes?: CT | ((t: DefaultColumnTypes) => CT);
     autoPreparedStatements?: boolean;
     noPrimaryKey?: NoPrimaryKeyOption;
+    snakeCase?: boolean;
 };
 declare type DbTableOptions = {
     schema?: string;
@@ -782,17 +788,7 @@ interface Db<Table extends string | undefined = undefined, Shape extends Columns
     onQueryBuilder: Query['onQueryBuilder'];
     primaryKeys: Query['primaryKeys'];
     query: QueryData;
-    selectable: {
-        [K in keyof Shape]: {
-            as: K;
-            column: Shape[K];
-        };
-    } & {
-        [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
-            as: K;
-            column: Shape[K];
-        };
-    };
+    selectable: SelectableFromShape<Shape, Table>;
     returnType: Query['returnType'];
     then: ThenResult<Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]>;
     joinedTables: Query['joinedTables'];
@@ -839,7 +835,9 @@ declare class With {
 }
 
 declare type UnionArg<T extends Query> = (Omit<Query, 'result'> & {
-    result: T['result'];
+    result: {
+        [K in keyof T['result']]: Pick<T['result'][K], 'dataType'>;
+    };
 }) | RawExpression;
 declare class Union {
     union<T extends Query>(this: T, args: UnionArg<T>[], wrap?: boolean): T;
@@ -921,9 +919,15 @@ declare type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<Data
 declare type CreateRelationData<T extends Query> = {
     [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation ? CreateBelongsToData<T, K, T['relations'][K]> : T['relations'][K] extends HasOneRelation ? CreateHasOneData<T, K, T['relations'][K]> : T['relations'][K] extends HasManyRelation | HasAndBelongsToManyRelation ? CreateHasManyData<T, K, T['relations'][K]> : EmptyObject;
 }[keyof T['relations']];
-declare type CreateBelongsToData<T extends Query, Key extends keyof T['relations'], Rel extends BelongsToRelation> = SetOptional<{
+declare type CreateBelongsToData<T extends Query, Key extends keyof T['relations'], Rel extends BelongsToRelation, FKeys = {
     [K in Rel['options']['foreignKey']]: Rel['options']['foreignKey'] extends keyof T['inputType'] ? T['inputType'][Rel['options']['foreignKey']] : never;
-}, keyof T[defaultsKey]> | {
+}> = {
+    [K in keyof FKeys]: K extends keyof T[defaultsKey] ? {
+        [L in K]?: FKeys[L];
+    } : {
+        [L in K]: FKeys[L];
+    };
+}[keyof FKeys] | {
     [K in Key]: {
         create: CreateData<Rel['nestedCreateQuery']>;
         connect?: never;
@@ -1481,6 +1485,17 @@ declare type SelectableBase = Record<PropertyKey, {
     as: string;
     column: ColumnType;
 }>;
+declare type SelectableFromShape<Shape extends ColumnsShapeBase, Table extends string | undefined> = {
+    [K in keyof Shape]: {
+        as: K;
+        column: Shape[K];
+    };
+} & {
+    [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
+        as: K;
+        column: Shape[K];
+    };
+};
 declare type WithDataItem = {
     table: string;
     shape: ColumnsShape;
@@ -1881,7 +1896,6 @@ declare type ColumnData = ColumnDataBase & {
     collate?: string;
     compression?: string;
     foreignKeys?: ForeignKey<string, string[]>[];
-    modifyQuery?: (q: Query) => void;
 };
 declare type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
 declare type ForeignKeyAction = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';
@@ -1960,7 +1974,6 @@ declare abstract class ColumnType<Type = unknown, Ops extends BaseOperators = Ba
     };
     as<T extends ColumnType, C extends ColumnType<T['type'], BaseOperators, T['inputType']>>(this: T, column: C): C;
     toSQL(): string;
-    default<T extends ColumnType, Value extends T['type'] | RawExpression>(this: T, value: Value): ColumnWithDefault<T, Value>;
     index<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column'>): T;
     unique<T extends ColumnType>(this: T, options?: Omit<SingleColumnIndexOptions, 'column' | 'unique'>): T;
     comment<T extends ColumnType>(this: T, comment: string): T;
@@ -1989,7 +2002,7 @@ declare type NumberMethods = typeof numberTypeMethods;
 interface NumberBaseColumn extends ColumnType<number, typeof Operators.number>, NumberMethods {
 }
 declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operators.number> {
-    data: BaseNumberData;
+    data: NumberColumnData;
     operators: {
         lt: ((key: string, value: number | RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
             type: number | RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
@@ -2021,10 +2034,10 @@ declare abstract class NumberBaseColumn extends ColumnType<number, typeof Operat
     };
 }
 declare abstract class IntegerBaseColumn extends NumberBaseColumn {
-    data: BaseNumberData;
+    data: NumberColumnData;
+    constructor(types: ColumnTypesBase);
 }
 declare abstract class NumberAsStringBaseColumn extends ColumnType<string, typeof Operators.number> {
-    data: {};
     operators: {
         lt: ((key: string, value: number | RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
             type: number | RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
@@ -2120,20 +2133,25 @@ declare class DoublePrecisionColumn extends NumberAsStringBaseColumn {
     toCode(t: string): Code;
 }
 declare class SmallSerialColumn extends IntegerBaseColumn {
-    dataType: "smallserial";
+    dataType: "smallint";
     parseItem: typeof parseInt;
     data: SerialColumnData;
+    constructor(types: ColumnTypesBase);
+    toSQL(): string;
     toCode(t: string): Code;
 }
 declare class SerialColumn extends IntegerBaseColumn {
-    dataType: "serial";
+    dataType: "integer";
     parseItem: typeof parseInt;
     data: SerialColumnData;
+    constructor(types: ColumnTypesBase);
+    toSQL(): string;
     toCode(t: string): Code;
 }
 declare class BigSerialColumn extends NumberAsStringBaseColumn {
-    dataType: "bigserial";
+    dataType: "bigint";
     data: SerialColumnData;
+    toSql(): string;
     toCode(t: string): Code;
 }
 
@@ -2245,7 +2263,7 @@ declare const textMethods: {
 interface TextBaseColumn extends ColumnType<string, typeof Operators.text>, TextMethods {
 }
 declare abstract class TextBaseColumn extends ColumnType<string, typeof Operators.text> {
-    data: BaseStringData;
+    data: TextColumnData;
     operators: {
         contains: ((key: string, value: string | orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query, values: unknown[]) => string) & {
             type: string | orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
@@ -2328,22 +2346,9 @@ declare class TextColumn extends TextBaseColumn {
             type: string[] | orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>> | Query;
         };
     };
-    data: orchid_core.ColumnDataBase & {
-        min?: number | undefined;
-        max?: number | undefined;
-        length?: number | undefined;
-        email?: boolean | undefined;
-        url?: boolean | undefined;
-        uuid?: boolean | undefined;
-        cuid?: boolean | undefined;
-        regex?: RegExp | undefined;
-        startsWith?: string | undefined;
-        endsWith?: string | undefined;
-        trim?: boolean | undefined;
-        isNonEmpty?: true | undefined;
-    } & {
-        minArg?: number | undefined;
-        maxArg?: number | undefined;
+    data: TextColumnData & {
+        minArg?: number;
+        maxArg?: number;
     };
     constructor(types: ColumnTypesBase, minArg?: number, maxArg?: number);
     toCode(t: string): Code;
@@ -3345,16 +3350,28 @@ declare const getTableData: () => TableData;
 declare const resetTableData: (data?: TableData) => void;
 declare const getColumnTypes: <CT extends ColumnTypesBase, Shape extends ColumnsShape>(types: CT, fn: (t: CT) => Shape, data?: TableData) => Shape;
 declare function text(this: ColumnTypesBase, min: number, max: number): TextColumn;
-declare function timestamps<T extends ColumnType>(this: {
-    timestamp(): T;
-}): {
-    createdAt: ColumnWithDefault<T, RawExpression>;
-    updatedAt: ColumnWithDefault<T, RawExpression>;
-};
 declare type DefaultColumnTypes = typeof columnTypes;
 declare const columnTypes: {
+    timestamps: <T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T;
+        };
+        timestamp(): T;
+    }) => {
+        createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+        updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+    };
+    timestampsSnakeCase: <T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>(this: {
+        name(name: string): {
+            timestamp(): T_1;
+        };
+        timestamp(): T_1;
+    }) => {
+        createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+        updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>>;
+    };
     name: typeof name;
-    raw: (sql: string, values?: false | Record<string, unknown> | undefined) => RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
+    raw: (sql: string, values?: false | Record<string, unknown> | undefined) => orchid_core.RawExpression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, orchid_core.ColumnDataBase>>;
     smallint(this: ColumnTypesBase): SmallIntColumn;
     integer(this: ColumnTypesBase): IntegerColumn;
     bigint(this: ColumnTypesBase): BigIntColumn;
@@ -3378,7 +3395,7 @@ declare const columnTypes: {
     timeWithTimeZone<Precision_5 extends number | undefined = undefined>(this: ColumnTypesBase, precision?: Precision_5 | undefined): TimeWithTimeZoneColumn<Precision_5>;
     interval<Fields extends string | undefined = undefined, Precision_6 extends number | undefined = undefined>(this: ColumnTypesBase, fields?: Fields | undefined, precision?: Precision_6 | undefined): IntervalColumn<Fields, Precision_6>;
     boolean(this: ColumnTypesBase): BooleanColumn;
-    enum<U extends string, T extends [U, ...U[]]>(this: ColumnTypesBase, dataType: string, type: T): EnumColumn<U, T>;
+    enum<U extends string, T_2 extends [U, ...U[]]>(this: ColumnTypesBase, dataType: string, type: T_2): EnumColumn<U, T_2>;
     point(this: ColumnTypesBase): PointColumn;
     line(this: ColumnTypesBase): LineColumn;
     lseg(this: ColumnTypesBase): LsegColumn;
@@ -3399,7 +3416,6 @@ declare const columnTypes: {
     json<Type extends JSONTypeAny>(this: ColumnTypesBase, schemaOrFn: Type | ((j: JSONTypes) => Type)): JSONColumn<Type>;
     jsonText(this: ColumnTypesBase): JSONTextColumn;
     array<Item extends ColumnType<unknown, orchid_core.BaseOperators, unknown>>(this: ColumnTypesBase, item: Item): ArrayColumn<Item>;
-    timestamps: typeof timestamps;
     primaryKey(columns: string[], options?: {
         name?: string;
     }): {};
@@ -3475,4 +3491,4 @@ declare const setQueryObjectValue: <T extends {
     query: QueryData;
 }>(q: T, object: string, key: string, value: unknown) => T;
 
-export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, BaseRelation, BeforeCallback, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, ColumnData, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnNameOfTable, ColumnOperators, ColumnParser, ColumnType, ColumnTypes, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DoublePrecisionColumn, DropMode, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, For, ForeignKey, ForeignKeyOptions, ForeignKeyTable, ForeignKeyTableWithColumns, From, FromArgs, FromResult, GetArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, JSONTypes, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operators, OrderArg, OrderItem, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryError, QueryErrorName, QueryGet, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySelectAll, QueryThen, QueryUpsertOrCreate, QueryWithTable, RawMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SerialColumn, SerialColumnData, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, Sql, StringColumn, StringExpression, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, checkIfASimpleQuery, cloneQueryArrays, codeToString, columnCode, columnDefaultArgumentToCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, createDb, defaultsKey, foreignKeyArgsToCode, foreignKeyArgumentToCode, foreignKeyToCode, getClonedQueryData, getColumnTypes, getQueryAs, getRaw, getShapeFromSelect, getTableData, getValueKey, handleResult, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, jsonTypes, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, relationQueryKey, resetTableData, setQueryObjectValue, toSql, toSqlCacheKey };
+export { Adapter, AdapterOptions, AddQueryJoinedTable, AddQuerySelect, AddQueryWith, AfterCallback, Aggregate, Aggregate1ArgumentTypes, AggregateArg, AggregateItem, AggregateItemArg, AggregateItemOptions, AggregateOptions, AliasOrTable, ArrayColumn, ArrayData, ArrayOfColumnsObjects, BaseRelation, BeforeCallback, BelongsToRelation, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BooleanExpression, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ClearStatement, ColumnData, ColumnFromDbParams, ColumnInfo, ColumnInfoMethods, ColumnInfoQueryData, ColumnNameOfTable, ColumnOperators, ColumnParser, ColumnType, ColumnTypes, ColumnsObject, ColumnsParsers, ColumnsShape, CommonQueryData, CopyOptions, CopyQueryData, Create, CreateCtx, CreateData, CreateMethodsNames, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeWithTimeZoneBaseClass, Db, DbOptions, DbResult, DbTableOptions, DecimalBaseColumn, DecimalColumn, DefaultColumnTypes, Delete, DeleteMethodsNames, DeleteQueryData, DoublePrecisionColumn, DropMode, EnumColumn, Expression, ExpressionOfType, ExpressionOutput, For, ForeignKey, ForeignKeyOptions, ForeignKeyTable, ForeignKeyTableWithColumns, From, FromArgs, FromResult, GetArg, HasAndBelongsToManyRelation, HasManyRelation, HasOneRelation, Having, HavingArg, HavingItem, IndexColumnOptions, IndexOptions, InetColumn, InsertQueryData, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, JSONTypes, Join, JoinArgs, JoinCallback, JoinCallbackArg, JoinItem, JoinResult, JoinedTablesBase, Json, JsonItem, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQuery, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NoPrimaryKeyOption, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, NumberColumn, NumberColumnData, NumberExpression, OnConflictItem, OnConflictMergeUpdate, OnConflictQueryBuilder, OnQueryBuilder, Operators, OrchidInternalError, OrderArg, OrderItem, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, Query, QueryArraysResult, QueryBase, QueryCallbacks, QueryData, QueryError, QueryErrorName, QueryGet, QueryLog, QueryLogObject, QueryLogOptions, QueryLogger, QueryMethods, QueryResult, QueryReturnType, QueryReturnsAll, QuerySelectAll, QueryThen, QueryUpsertOrCreate, QueryWithTable, RawMethods, RealColumn, Relation, RelationQuery, RelationQueryBase, RelationQueryData, RelationsBase, Select, SelectAgg, SelectArg, SelectFunctionItem, SelectItem, SelectQueryData, Selectable, SelectableBase, SelectableFromShape, SerialColumn, SerialColumnData, SetQueryJoinedTables, SetQueryReturns, SetQueryReturnsAll, SetQueryReturnsColumnInfo, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsPluck, SetQueryReturnsRowCount, SetQueryReturnsRows, SetQueryReturnsValue, SetQueryReturnsValueOptional, SetQueryReturnsVoid, SetQueryTableAlias, SetQueryWindows, SetQueryWith, SingleColumnIndexOptions, SmallIntColumn, SmallSerialColumn, SortDir, Sql, StringColumn, StringExpression, TableData, TextBaseColumn, TextColumn, TextColumnData, Then, TimeColumn, TimeInterval, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, ToSqlCtx, ToSqlOptions, Transaction, TransactionAdapter, TruncateQueryData, TsQueryColumn, TsVectorColumn, TypeParsers, UUIDColumn, UnhandledTypeError, Union, UnionArg, UnionItem, UnionKind, Update, UpdateCtx, UpdateData, UpdateQueryData, UpdateQueryDataItem, UpdateQueryDataObject, UpdatedAtDataInjector, UpsertData, UpsertResult, UpsertThis, VarCharColumn, VirtualColumn, Where, WhereArg, WhereInArg, WhereInColumn, WhereInItem, WhereInValues, WhereItem, WhereJsonPathEqualsItem, WhereOnItem, WhereOnJoinItem, WhereQueryBuilder, WhereResult, WindowArg, WindowArgDeclaration, WindowDeclaration, WindowFunctionOptions, WindowItem, With, WithDataBase, WithDataItem, WithItem, WithOptions, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, checkIfASimpleQuery, cloneQueryArrays, codeToString, columnCode, columnDefaultArgumentToCode, columnForeignKeysToCode, columnIndexesToCode, columnTypes, utils as columnUtils, columnsByType, columnsShapeToCode, createDb, defaultsKey, foreignKeyArgsToCode, foreignKeyArgumentToCode, foreignKeyToCode, getClonedQueryData, getColumnTypes, getQueryAs, getRaw, getShapeFromSelect, getTableData, getValueKey, handleResult, indexToCode, instantiateColumn, isQueryReturnsAll, isRequiredRelationKey, jsonTypes, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, newTableData, parseRecord, parseResult, primaryKeyToCode, processSelectArg, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, quoteString, relationQueryKey, resetTableData, setQueryObjectValue, toSql, toSqlCacheKey };