@ignisia/sql 0.4.0 → 0.4.2

package/dist/esm/{index-CjurLJdK.d.ts → index-CsVPGz2o.d.ts}

@@ -1,7 +1,7 @@
 import { Column } from './column/index.js';
 import { TransactionSQL } from 'bun';
 import { UnionToIntersection, Multiply, Subtract } from './types.js';
-import { QueryType, OrderBy, AggregationFunction, ExplainClause, ExplainFormat, AcceptedOperator, QueryHooksType, ConditionClause, LogicalOperator } from './query/constants.js';
+import { QueryType, OrderBy, AggregationFunction, ExplainClause, ExplainFormat, AcceptedOperator, QueryHooksType, ConditionClause, LogicalOperator, AstType, AcceptedJoin } from './query/constants.js';
 import { AcceptedColumnTypes } from './column/constants.js';
 import { Dialect } from './table/constants.js';
 
@@ -12,7 +12,7 @@ type StrictColumnSelector<Alias extends string, TableRef extends Table<string, R
     [A in keyof JoinedTables]: `${A & string}."${keyof JoinedTables[A]['columns'] & string}"`;
 }[keyof JoinedTables];
 type WhereValue<T extends Column> = {
-    [K in AcceptedOperator]: K extends typeof AcceptedOperator.BETWEEN | typeof AcceptedOperator.NOT_BETWEEN ? [T['_output'], T['_output']] : K extends typeof AcceptedOperator.IN | typeof AcceptedOperator.NOT_IN ? T['_output'][] : K extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL ? never : K extends typeof AcceptedOperator.STARTS_WITH | typeof AcceptedOperator.ENDS_WITH ? T['_output'] : T['_output'];
+    [K in AcceptedOperator]: K extends typeof AcceptedOperator.BETWEEN ? [T['_output'], T['_output']] : K extends typeof AcceptedOperator.IN ? T['_output'][] : K extends typeof AcceptedOperator.IS_NULL ? never : K extends typeof AcceptedOperator.STARTS_WITH | typeof AcceptedOperator.ENDS_WITH ? T['_output'] : T['_output'];
 };
 type AcceptedOrderBy<Columns extends string> = {
     column: Columns;
@@ -54,9 +54,8 @@ type AggregateColumn<Allowed extends string, Fn extends AggregationFunction = Ag
 interface QueryDefinition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>> = NonNullable<unknown>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables> = ColumnSelector<Alias, TableRef, JoinedTables>> {
     queryType: QueryType | null;
     select: SelectableColumn<AllowedColumn>[] | null;
-    where: string[] | null;
-    having: string[] | null;
-    params: unknown[] | null;
+    where: GroupNode;
+    having: GroupNode;
     limit: number | null;
     offset: number | null;
     groupBy: AllowedColumn[] | null;
@@ -65,7 +64,7 @@ interface QueryDefinition<Alias extends string, TableRef extends Table<string, R
     orderBy: AcceptedOrderBy<AllowedColumn>[] | null;
     aggregates: AggregateColumn<AllowedColumn>[] | null;
     distinct: boolean | null;
-    joins: string[] | null;
+    joins: JoinNode[];
     baseAlias: Alias | null;
     withDeleted: boolean | null;
     joinedTables: JoinedTables | null;
@@ -136,32 +135,13 @@ interface ExplainOptions extends Partial<Record<Lowercase<Exclude<ExplainClause,
 }
 
 declare function addCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Clause extends ConditionClause, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator], Logical extends LogicalOperator, ValidClause extends Lowercase<Clause>>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, clause: Clause, column: ColName, operator: Operator, value: Value, logical: Logical, negate: boolean): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, ValidClause> & { [Key in ValidClause]: string[]; }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, ValidClause> & { [Key in ValidClause]: string[]; }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, ValidClause> & { [Key in ValidClause]: string[]; }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
-declare function addGroupCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Logical extends LogicalOperator>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, logical: Logical, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>, negate: boolean): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-
-declare function alias<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, NewAlias extends string>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, "baseAlias"> & {
-    baseAlias: NewAlias;
-}>;
-declare function clone<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-declare function rawCol<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn>(column: ColName): ColName;
-declare function col<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(column: ColName, alias: ColAlias): {
-    readonly column: ColName;
-    readonly as: ColAlias;
-};
-declare function aggregateCol<StrictAllowedColumn extends string, Aggregate extends AggregationFunction = AggregationFunction, ColName extends StrictAllowedColumn = StrictAllowedColumn>(fn: Aggregate, column: ColName): {
-    column: ColName;
-    as: Lowercase<Aggregate>;
-    fn: Aggregate;
-};
-declare function aggregateCol<StrictAllowedColumn extends string, Aggregate extends AggregationFunction = AggregationFunction, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(fn: Aggregate, column: ColName, alias: ColAlias): {
-    column: ColName;
-    as: ColAlias;
-    fn: Aggregate;
-};
-
-declare function addRawCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Clause extends ConditionClause, Logical extends LogicalOperator, ValidClause extends Lowercase<Clause>>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, clause: Clause, column: (c: typeof rawCol) => string, logical: Logical, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-declare function rawWhere<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-declare function rawOr<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
-declare function rawHaving<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+declare function addGroupCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Logical extends LogicalOperator>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, logical: Logical, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>, negate: boolean): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: GroupNode;
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
 
 interface QueryTransformerContract<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>> {
     toQuery(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, dialect?: Dialect | null): {
@@ -174,26 +154,22 @@ interface QueryTransformerContract<Alias extends string, TableRef extends Table<
     explain(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, options: ExplainOptions): Promise<unknown>;
     exec<This extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn> = QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends This['_output'] = This['_output']>(this: This, tx?: TransactionSQL | null): Promise<Output>;
     clone(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): typeof this;
-    alias<NewAlias extends string>(alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, 'baseAlias'> & {
+    alias<NewAlias extends string>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, 'baseAlias'> & {
         baseAlias: NewAlias;
     }>;
 }
 interface QueryConditionContract<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>> {
-    rawWhere(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
-    rawOr(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
-    rawHaving(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
-    where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
+    where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
     where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
-    or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
+    or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
     or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
-    on<ColName extends StrictAllowedColumn, Operator extends typeof AcceptedOperator.EQ | typeof AcceptedOperator.NE>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, columnA: ColName, operator: Operator, columnB: ColName): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, ColName, typeof LogicalOperator.ON, Lowercase<typeof ConditionClause.WHERE>>>;
     having<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
     whereGroup(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): ReturnType<typeof addGroupCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof LogicalOperator.AND>>;
     orGroup(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): ReturnType<typeof addGroupCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof LogicalOperator.OR>>;
     not: {
-        where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
+        where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
         where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
-        or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
+        or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
         or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
         having<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
         whereGroup(callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): ReturnType<typeof addGroupCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof LogicalOperator.AND>>;
@@ -318,6 +294,65 @@ declare class Table<TableName extends string, Columns extends Record<string, Col
     query(): QueryBuilder<this["name"], this, {}, {}, ColumnSelector<this["name"], this, {}>, `${this["name"]}."${keyof this["columns"] & string}"`, QueryTransformerContract<this["name"], this, {}, {}, ColumnSelector<this["name"], this, {}>, `${this["name"]}."${keyof this["columns"] & string}"`>, QueryConditionContract<this["name"], this, {}, {}, ColumnSelector<this["name"], this, {}>, `${this["name"]}."${keyof this["columns"] & string}"`>>;
 }
 
+interface BaseComparisonNode {
+    type: typeof AstType.COMPARISON;
+    column: string;
+}
+interface SingleValueComparisonNode extends BaseComparisonNode {
+    operator: Exclude<AcceptedOperator, typeof AcceptedOperator.IN | typeof AcceptedOperator.BETWEEN>;
+    value: unknown;
+}
+interface MultiValueComparisonNode extends BaseComparisonNode {
+    operator: typeof AcceptedOperator.IN | typeof AcceptedOperator.BETWEEN;
+    values: unknown[];
+}
+interface NullValueComparisonNode extends BaseComparisonNode {
+    operator: typeof AcceptedOperator.IS_NULL;
+}
+type ComparisonNode = SingleValueComparisonNode | MultiValueComparisonNode | NullValueComparisonNode;
+interface GroupNode {
+    type: typeof AstType.GROUP;
+    operator: LogicalOperator;
+    children: AstNode[];
+}
+interface NotNode {
+    type: typeof AstType.NOT;
+    child: AstNode;
+}
+type AstNode = ComparisonNode | GroupNode | NotNode;
+interface BaseJoinNode {
+    type: typeof AstType.JOIN;
+    table: Table<string, Record<string, Column>>;
+    alias: string;
+}
+interface NonCrossNaturalJoinNode extends BaseJoinNode {
+    join: Exclude<AcceptedJoin, typeof AcceptedJoin.CROSS | typeof AcceptedJoin.NATURAL>;
+    on: AstNode;
+}
+interface CrossNaturalJoinNode extends BaseJoinNode {
+    join: typeof AcceptedJoin.CROSS | typeof AcceptedJoin.NATURAL;
+}
+type JoinNode = CrossNaturalJoinNode | NonCrossNaturalJoinNode;
+
+declare function alias<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, NewAlias extends string>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, "baseAlias"> & {
+    baseAlias: NewAlias;
+}>;
+declare function clone<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+declare function col<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(column: ColName, alias: ColAlias): {
+    readonly column: ColName;
+    readonly as: ColAlias;
+};
+declare function aggregateCol<StrictAllowedColumn extends string, Aggregate extends AggregationFunction = AggregationFunction, ColName extends StrictAllowedColumn = StrictAllowedColumn>(fn: Aggregate, column: ColName): {
+    column: ColName;
+    as: Lowercase<Aggregate>;
+    fn: Aggregate;
+};
+declare function aggregateCol<StrictAllowedColumn extends string, Aggregate extends AggregationFunction = AggregationFunction, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(fn: Aggregate, column: ColName, alias: ColAlias): {
+    column: ColName;
+    as: ColAlias;
+    fn: Aggregate;
+};
+
 declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>> = NonNullable<unknown>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>> = NonNullable<unknown>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables> = ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables> = StrictColumnSelector<Alias, TableRef, JoinedTables>, TransformerContract extends QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn> = QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryContract extends QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn> = QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>> {
     readonly hooks: Partial<QueryHooks>;
     readonly table: TableRef;
@@ -330,14 +365,9 @@ declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Tabl
     toDebugString: TransformerContract['toDebugString'];
     explain: TransformerContract['explain'];
     exec: TransformerContract['exec'];
-    rawWhere: QueryContract['rawWhere'];
-    rawAnd: QueryContract['rawWhere'];
-    rawOr: QueryContract['rawOr'];
-    rawHaving: QueryContract['rawHaving'];
     where: QueryContract['where'];
     and: QueryContract['where'];
     or: QueryContract['or'];
-    on: QueryContract['on'];
     having: QueryContract['having'];
     whereGroup: QueryContract['whereGroup'];
     orGroup: QueryContract['orGroup'];
@@ -345,74 +375,72 @@ declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Tabl
     constructor(table: TableRef);
     leftJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): {
         on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>, QueryTransformerContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>, QueryConditionContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
     };
     rightJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): {
         on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>, QueryTransformerContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>, QueryConditionContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
     };
     innerJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): {
         on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>, QueryTransformerContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>, QueryConditionContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
     };
     fullJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): {
         on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>, QueryTransformerContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>, QueryConditionContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
+            joins: JoinNode[];
             joinedTables: ReturnedJoinedTables;
         }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
     };
     crossJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): QueryBuilder<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
-        joins: string[];
+        joins: JoinNode[];
         joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
     }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, QueryTransformerContract<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
-        joins: string[];
+        joins: JoinNode[];
         joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
     }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>, QueryConditionContract<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
-        joins: string[];
+        joins: JoinNode[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>>;
+    naturalJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): QueryBuilder<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: JoinNode[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, QueryTransformerContract<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: JoinNode[];
+        joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
+    }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>, QueryConditionContract<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: JoinNode[];
         joinedTables: JoinedTables & { [K in JoinAlias]: JoinTable; };
     }, ColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>, StrictColumnSelector<Alias, TableRef, JoinedTables & { [K in JoinAlias]: JoinTable; }>>>;
-    naturalJoin<JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(joinTable: JoinTable, alias: JoinAlias): {
-        on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>, QueryTransformerContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>, QueryConditionContract<Alias, TableRef, FinalJoinedTables, {}, ColumnSelector<Alias, TableRef, FinalJoinedTables>, StrictColumnSelector<Alias, TableRef, FinalJoinedTables>>>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, {}, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
-            joinedTables: ReturnedJoinedTables;
-        }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
-            joinedTables: ReturnedJoinedTables;
-        }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-            joins: string[];
-            joinedTables: ReturnedJoinedTables;
-        }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
-    };
     distinct(): QueryBuilder<Alias, TableRef, JoinedTables, Definition & {
         distinct: true;
     }>;
@@ -469,4 +497,4 @@ declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Tabl
     infer(): this['_output'];
 }
 
-export { type AliasedColumn as A, alias as B, type ColumnSelector as C, type DatabaseDefinition as D, type ExplainOptions as E, clone as F, rawCol as G, col as H, aggregateCol as I, type SqlConfig as J, createdAt as K, updatedAt as L, type MergeTimestampParanoid as M, deletedAt as N, defineColumns as O, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type SqlConfigMapping as S, Table as T, type TableOptions as U, type TableOutput as V, type WhereValue as W, type ExecOptions as X, addCondition as a, addGroupCondition as b, addRawCondition as c, rawOr as d, rawHaving as e, type TimestampOptions as f, type DatabaseDialect as g, type DatabaseExecOptions as h, type MysqlConfig as i, type SqliteConfig as j, type StrictColumnSelector as k, QueryBuilder as l, type SelectableColumn as m, type QueryTransformerContract as n, type QueryConditionContract as o, type QueryHooks as p, type DatabaseOptions as q, rawWhere as r, type QueryRunHooks as s, type AcceptedOrderBy as t, type AcceptedInsertValues as u, type AcceptedUpdateValues as v, type AggregateColumn as w, type SelectQueryOutput as x, type QueryOutput as y, type QueryRunHooksOptions as z };
+export { clone as $, type AliasedColumn as A, deletedAt as B, type ColumnSelector as C, type DatabaseDefinition as D, type ExplainOptions as E, defineColumns as F, type GroupNode as G, type TableOptions as H, type TableOutput as I, type JoinNode as J, type ExecOptions as K, type SingleValueComparisonNode as L, type MergeTimestampParanoid as M, type MultiValueComparisonNode as N, type NullValueComparisonNode as O, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type StrictColumnSelector as S, Table as T, type ComparisonNode as U, type NotNode as V, type WhereValue as W, type BaseJoinNode as X, type NonCrossNaturalJoinNode as Y, type CrossNaturalJoinNode as Z, alias as _, addCondition as a, col as a0, aggregateCol as a1, addGroupCondition as b, QueryBuilder as c, type SelectableColumn as d, type QueryTransformerContract as e, type QueryConditionContract as f, type AstNode as g, type TimestampOptions as h, type SqlConfigMapping as i, type DatabaseDialect as j, type DatabaseExecOptions as k, type MysqlConfig as l, type SqliteConfig as m, type QueryHooks as n, type DatabaseOptions as o, type QueryRunHooks as p, type AcceptedOrderBy as q, type AcceptedInsertValues as r, type AcceptedUpdateValues as s, type AggregateColumn as t, type SelectQueryOutput as u, type QueryOutput as v, type QueryRunHooksOptions as w, type SqlConfig as x, createdAt as y, updatedAt as z };

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
 export { Column } from './column/index.js';
-export { D as Database } from './index-DgOs61lH.js';
+export { D as Database } from './index-BWg1JZRt.js';
 export { Migration } from './migration/index.js';
-export { l as QueryBuilder, T as Table } from './index-CjurLJdK.js';
+export { c as QueryBuilder, T as Table } from './index-CsVPGz2o.js';
 import './table/constants.js';
 import './column/constants.js';
 import './column/types.js';

package/dist/esm/migration/index.d.ts

@@ -1,6 +1,6 @@
 import { Column } from '../column/index.js';
-import { D as Database } from '../index-DgOs61lH.js';
-import { T as Table } from '../index-CjurLJdK.js';
+import { D as Database } from '../index-BWg1JZRt.js';
+import { T as Table } from '../index-CsVPGz2o.js';
 import { Dialect } from '../table/constants.js';
 import { MigrationOptions, MigrationFn } from './type.js';
 import '../column/constants.js';

package/dist/esm/migration/type.d.ts

@@ -1,6 +1,6 @@
 import { Column } from '../column/index.js';
-import { D as Database } from '../index-DgOs61lH.js';
-import { T as Table } from '../index-CjurLJdK.js';
+import { D as Database } from '../index-BWg1JZRt.js';
+import { T as Table } from '../index-CsVPGz2o.js';
 import { Dialect } from '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';

package/dist/esm/query/ast.d.ts

@@ -0,0 +1,8 @@
+import '../column/index.js';
+export { g as AstNode, X as BaseJoinNode, U as ComparisonNode, Z as CrossNaturalJoinNode, G as GroupNode, J as JoinNode, N as MultiValueComparisonNode, Y as NonCrossNaturalJoinNode, V as NotNode, O as NullValueComparisonNode, L as SingleValueComparisonNode } from '../index-CsVPGz2o.js';
+import './constants.js';
+import '../table/constants.js';
+import '../column/constants.js';
+import '../column/types.js';
+import 'bun';
+import '../types.js';

package/dist/esm/query/ast.js

@@ -0,0 +1 @@
+

package/dist/esm/query/builder.d.ts

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder } from '../index-CjurLJdK.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, S as StrictColumnSelector, c as QueryBuilder } from '../index-CsVPGz2o.js';
 import { Column } from '../column/index.js';
 import 'bun';
 import '../types.js';
@@ -8,8 +8,8 @@ import '../table/constants.js';
 import '../column/types.js';
 
 declare function buildSelectQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
-declare function buildInsertQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
-declare function buildUpdateQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
+declare function buildInsertQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, params: unknown[]): string;
+declare function buildUpdateQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, params: unknown[]): string;
 declare function buildDeleteQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
 
 export { buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery };

package/dist/esm/query/builder.js

@@ -30,7 +30,7 @@ function buildSelectQuery(q) {
   const distinct = q.definition.distinct ? "DISTINCT " : "";
   return `SELECT ${distinct}${columns.join(", ")} FROM ${from}`;
 }
-function buildInsertQuery(q) {
+function buildInsertQuery(q, params) {
   const rows = q.definition?.insertValues;
   if (!rows?.length) {
     throw new Error(`INSERT requires values`);
@@ -39,12 +39,14 @@ function buildInsertQuery(q) {
   const columns = keys.map(quoteIdentifier).join(", ");
   const rowPlaceholders = `(${keys.map(() => "?").join(", ")})`;
   const placeholders = rows.map(() => rowPlaceholders).join(", ");
-  q.definition.params = rows.flatMap(
-    (row) => keys.map((key) => row[key])
+  params.push(
+    ...rows.flatMap(
+      (row) => keys.map((key) => row[key])
+    )
   );
-  return `INSERT INTO ${q.table.name} (${columns}) VALUES ${placeholders} RETURNING *`;
+  return `INSERT INTO ${q.table.name} (${columns}) VALUES ${placeholders}`;
 }
-function buildUpdateQuery(q) {
+function buildUpdateQuery(q, params) {
   if (!q.definition?.updateValues) {
     throw new Error(`UPDATE requires values`);
   }
@@ -53,11 +55,7 @@ function buildUpdateQuery(q) {
     (key) => q.definition.updateValues[key]
   );
   keys = keys.map(quoteIdentifier);
-  if (q.definition?.params) {
-    q.definition.params = [...updateParams, ...q.definition.params];
-  } else {
-    q.definition.params = updateParams;
-  }
+  params.unshift(...updateParams);
   return `UPDATE ${q.table.name} SET ${keys.map((key) => `${key} = ?`).join(", ")}`;
 }
 function buildDeleteQuery(q) {

package/dist/esm/query/compiler.d.ts

@@ -0,0 +1,13 @@
+import { Dialect } from '../table/constants.js';
+import { g as AstNode, J as JoinNode } from '../index-CsVPGz2o.js';
+import '../column/index.js';
+import '../column/constants.js';
+import '../column/types.js';
+import 'bun';
+import '../types.js';
+import './constants.js';
+
+declare function compileAst(dialect: Dialect | null, node: AstNode, params: unknown[]): string;
+declare function compileJoin(dialect: Dialect | null, join: JoinNode, params: unknown[]): string;
+
+export { compileAst, compileJoin };

package/dist/esm/query/compiler.js

@@ -0,0 +1,112 @@
+import { Dialect } from '../table/constants.js';
+import { AstType, AcceptedJoin, AcceptedOperator } from './constants.js';
+
+// src/query/compiler.ts
+function compileComparison(dialect, node, params) {
+  const column = node.column;
+  if (node.operator === AcceptedOperator.BETWEEN || node.operator === AcceptedOperator.IN) {
+    params.push(...node.values);
+  } else if (node.operator !== AcceptedOperator.IS_NULL && "value" in node) {
+    params.push(node.value);
+  }
+  switch (node.operator) {
+    case AcceptedOperator.EQ:
+      return `${column} = ?`;
+    case AcceptedOperator.NE:
+      return `${column} != ?`;
+    case AcceptedOperator.GT:
+      return `${column} > ?`;
+    case AcceptedOperator.LT:
+      return `${column} < ?`;
+    case AcceptedOperator.GTE:
+      return `${column} >= ?`;
+    case AcceptedOperator.LTE:
+      return `${column} <= ?`;
+    case AcceptedOperator.IN:
+      return `${column} IN (${node.values.map(() => "?").join(", ")})`;
+    case AcceptedOperator.LIKE:
+      return `${column} LIKE ?`;
+    case AcceptedOperator.ILIKE:
+      if (dialect === Dialect.POSTGRES) {
+        return `${column} ILIKE ?`;
+      }
+      return `LOWER(${column}) LIKE LOWER(?)`;
+    case AcceptedOperator.IS_NULL:
+      return `${column} IS NULL`;
+    case AcceptedOperator.BETWEEN:
+      return `${column} BETWEEN ? AND ?`;
+    case AcceptedOperator.STARTS_WITH:
+      return `${column} LIKE ?`;
+    case AcceptedOperator.ENDS_WITH:
+      return `${column} LIKE ?`;
+    case AcceptedOperator.REG_EXP: {
+      switch (dialect) {
+        case Dialect.POSTGRES:
+          return `${column} ~ ?`;
+        case Dialect.MYSQL:
+          return `${column} REGEXP ?`;
+        case Dialect.SQLITE:
+          return `${column} GLOB ?`;
+        default:
+          throw new Error("Operator not supported");
+      }
+    }
+    case AcceptedOperator.RLIKE: {
+      switch (dialect) {
+        case Dialect.POSTGRES:
+          return `${column} ~* ?`;
+        case Dialect.MYSQL:
+          return `${column} RLIKE ?`;
+        case Dialect.SQLITE:
+          return `${column} GLOB ?`;
+        default:
+          throw new Error("Operator not supported");
+      }
+    }
+    default:
+      throw new Error("Invalid operator");
+  }
+}
+function compileNot(dialect, node, params) {
+  const inner = compileAst(dialect, node.child, params);
+  return `NOT (${inner})`;
+}
+function compileGroup(dialect, node, params) {
+  if (!node.children.length) {
+    return "";
+  }
+  const compiled = node.children.map(
+    (child) => compileAst(dialect, child, params)
+  );
+  return `(${compiled.join(` ${node.operator} `)})`;
+}
+function compileAst(dialect, node, params) {
+  switch (node.type) {
+    case AstType.COMPARISON:
+      return compileComparison(dialect, node, params);
+    case AstType.GROUP:
+      return compileGroup(dialect, node, params);
+    case AstType.NOT:
+      return compileNot(dialect, node, params);
+    default:
+      throw new Error(`Unknown AST node type`);
+  }
+}
+function compileJoin(dialect, join, params) {
+  const table = join.table.name;
+  const alias = join.alias;
+  if (join.join === AcceptedJoin.CROSS || join.join === AcceptedJoin.NATURAL) {
+    return `${join.join} JOIN ${table} AS ${alias}`;
+  }
+  if (!join.on) {
+    throw new Error(`${join.join} join requires ON condition`);
+  }
+  const onSql = compileAst(
+    dialect,
+    join.on,
+    params
+  );
+  return `${join.join} JOIN ${table} AS ${alias} ON ${onSql}`;
+}
+
+export { compileAst, compileJoin };