rado 1.0.15 → 1.2.0

package/dist/core/expr/Input.js

@@ -1,12 +1,29 @@
 // src/core/expr/Input.ts
-import { getSql, getTable, hasSql, hasTable } from "../Internal.js";
+import {
+  getField,
+  getSql,
+  getTable,
+  hasField,
+  hasSql,
+  hasTable
+} from "../Internal.js";
 import { sql } from "../Sql.js";
-function input(value) {
-  if (typeof value !== "object" || value === null) return sql.value(value);
-  if (hasTable(value)) return sql.identifier(getTable(value).name);
-  if (hasSql(value)) return getSql(value);
-  return sql.value(value);
+function input(value, maybeField) {
+  const isObject = value && typeof value === "object";
+  if (isObject && hasTable(value))
+    return sql.identifier(getTable(value).aliased);
+  if (isObject && hasSql(value)) return getSql(value);
+  const fieldSource = maybeField && typeof maybeField === "object" && hasField(maybeField) && getField(maybeField).source;
+  return fieldSource && "mapToDriverValue" in fieldSource ? mapToColumn(fieldSource, value) : sql.value(value);
+}
+function mapToColumn({ mapToDriverValue }, expr) {
+  const isObject = expr && typeof expr === "object";
+  if (isObject && hasSql(expr)) return getSql(expr);
+  return input(
+    expr !== null && mapToDriverValue ? mapToDriverValue(expr) : expr
+  );
 }
 export {
-  input
+  input,
+  mapToColumn
 };

package/dist/core/expr/Json.js

@@ -11,8 +11,8 @@ function jsonExpr(e) {
       return jsonExpr(
         sql.jsonPath({
           target: getSql(target),
-          asSql: true,
-          segments: [isNumber ? Number(prop) : prop]
+          segments: [isNumber ? Number(prop) : prop],
+          asSql: true
         }).mapWith({
           mapFromDriverValue(value, specs) {
             return specs.parsesJson ? value : JSON.parse(value);

package/dist/core/query/CTE.d.ts

@@ -0,0 +1,8 @@
+import { type HasQuery, type HasTarget } from '../Internal.js';
+import type { SelectionInput } from '../Selection.js';
+import { type Sql } from '../Sql.js';
+import type { QueryBase } from './Query.js';
+import type { UnionBase } from './Select.js';
+export type CTE<Input = unknown> = Input & HasTarget & HasQuery;
+export declare function createCTE<Input extends SelectionInput>(cteName: string, query: UnionBase<Input>): CTE<Input>;
+export declare function formatCTE(query: QueryBase): Sql | undefined;

package/dist/core/query/CTE.js

@@ -0,0 +1,33 @@
+// src/core/query/CTE.ts
+import {
+  getQuery,
+  getSelection,
+  getTarget,
+  internalQuery
+} from "../Internal.js";
+import { sql } from "../Sql.js";
+function createCTE(cteName, query) {
+  const fields = getSelection(query).makeVirtual(cteName);
+  return Object.assign(fields, {
+    [internalQuery]: getQuery(query).nameSelf(cteName)
+  });
+}
+function formatCTE(query) {
+  const isRecursive = query.withRecursive;
+  const definitions = isRecursive ? query.withRecursive : query.with;
+  if (!definitions) return;
+  return sql.query({
+    [isRecursive ? "withRecursive" : "with"]: sql.join(
+      definitions.map((cte) => {
+        const query2 = getQuery(cte);
+        const target = getTarget(cte);
+        return sql`${target} as (${query2})`;
+      }),
+      sql`, `
+    )
+  });
+}
+export {
+  createCTE,
+  formatCTE
+};

package/dist/core/query/Delete.d.ts

@@ -1,22 +1,23 @@
-import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
+import { type HasQuery, type HasSql, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
-import { Query, type QueryData } from '../Query.js';
+import { type QueryData, SingleQuery } from '../Queries.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
 import type { TableDefinition, TableRow } from '../Table.js';
-export interface DeleteData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
-    from: HasTable;
-    where?: HasSql;
-    returning?: Selection;
-}
-export declare class Delete<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
-    readonly [internalData]: DeleteData<Meta>;
+import type { Input } from '../expr/Input.js';
+import type { DeleteQuery } from './Query.js';
+export declare class Delete<Result, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Result, Meta> implements HasQuery<Result> {
+    readonly [internalData]: QueryData<Meta> & DeleteQuery;
     readonly [internalSelection]?: Selection;
-    constructor(data: DeleteData<Meta>);
-    get [internalQuery](): Sql;
+    constructor(data: QueryData<Meta> & DeleteQuery);
+    get [internalQuery](): Sql<Result>;
+    limit(limit: Input<number>): Delete<Result, Meta>;
+    offset(offset: Input<number>): Delete<Result, Meta>;
+    orderBy(...orderBy: Array<HasSql>): Delete<Result, Meta>;
 }
 export declare class DeleteFrom<Definition extends TableDefinition, Meta extends QueryMeta> extends Delete<void, Meta> {
     where(...where: Array<HasSql<boolean> | undefined>): DeleteFrom<Definition, Meta>;
-    returning(this: DeleteFrom<Definition, IsPostgres | IsSqlite>): Delete<TableRow<Definition>, Meta>;
-    returning<Input extends SelectionInput>(this: DeleteFrom<Definition, IsPostgres | IsSqlite>, returning: Input): Delete<SelectionRow<Input>, Meta>;
+    returning(this: DeleteFrom<Definition, IsPostgres | IsSqlite>): Delete<Array<TableRow<Definition>>, Meta>;
+    returning<Input extends SelectionInput>(this: DeleteFrom<Definition, IsPostgres | IsSqlite>, returning: Input): Delete<Array<SelectionRow<Input>>, Meta>;
 }
+export declare function deleteQuery(query: DeleteQuery): Sql;

package/dist/core/query/Delete.js

@@ -1,25 +1,37 @@
 // src/core/query/Delete.ts
 import {
   getData,
+  getTable,
   internalData,
   internalQuery,
   internalSelection
 } from "../Internal.js";
-import { Query } from "../Query.js";
+import { SingleQuery } from "../Queries.js";
 import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
 import { and } from "../expr/Conditions.js";
-var Delete = class extends Query {
+import { formatCTE } from "./CTE.js";
+import { formatModifiers } from "./Shared.js";
+var Delete = class _Delete extends SingleQuery {
   [internalData];
   constructor(data) {
     super(data);
     this[internalData] = data;
-    if (data.returning) this[internalSelection] = data.returning;
+    if (data.returning) this[internalSelection] = selection(data.returning);
   }
   get [internalQuery]() {
-    return sql.chunk("emitDelete", this);
+    return deleteQuery(getData(this));
+  }
+  limit(limit) {
+    return new _Delete({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Delete({ ...getData(this), offset });
+  }
+  orderBy(...orderBy) {
+    return new _Delete({ ...getData(this), orderBy });
   }
 };
 var DeleteFrom = class _DeleteFrom extends Delete {
@@ -30,11 +42,25 @@ var DeleteFrom = class _DeleteFrom extends Delete {
     const data = getData(this);
     return new Delete({
       ...data,
-      returning: returning ? selection(returning) : selection.table(data.from)
+      returning: returning ?? data.delete
     });
   }
 };
+function deleteQuery(query) {
+  const { delete: from, where, returning } = query;
+  const table = getTable(from);
+  return sql.query(
+    formatCTE(query),
+    {
+      deleteFrom: sql.identifier(table.name),
+      where,
+      returning: returning && selection(returning)
+    },
+    formatModifiers(query)
+  );
+}
 export {
   Delete,
-  DeleteFrom
+  DeleteFrom,
+  deleteQuery
 };

package/dist/core/query/Insert.d.ts

@@ -1,50 +1,31 @@
-import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
+import { type HasQuery, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsMysql, IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
-import { Query, type QueryData } from '../Query.js';
+import { type QueryData, SingleQuery } from '../Queries.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
-import type { TableDefinition, TableInsert, TableRow, TableUpdate } from '../Table.js';
-interface InsertIntoData<Meta extends QueryMeta> extends QueryData<Meta> {
-    into: HasTable;
-    values?: HasSql;
-    select?: HasSql;
-}
-export interface InsertData<Meta extends QueryMeta> extends InsertIntoData<Meta> {
-    returning?: Selection;
-    onConflict?: HasSql;
-    onDuplicateKeyUpdate?: HasSql;
-}
-export declare class Insert<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
-    readonly [internalData]: InsertData<Meta>;
+import type { TableDefinition, TableInsert, TableRow } from '../Table.js';
+import type { InsertQuery, OnConflict, OnConflictSet, OnConflictUpdate } from './Query.js';
+export declare class Insert<Result, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Result, Meta> implements HasQuery<Result> {
+    readonly [internalData]: QueryData<Meta> & InsertQuery;
     readonly [internalSelection]?: Selection;
-    constructor(data: InsertData<Meta>);
-    get [internalQuery](): Sql;
+    constructor(data: QueryData<Meta> & InsertQuery);
+    get [internalQuery](): Sql<Result>;
 }
 declare class InsertCanReturn<Definition extends TableDefinition, Meta extends QueryMeta> extends Insert<void, Meta> {
-    returning(this: InsertCanReturn<Definition, IsPostgres | IsSqlite>): Insert<TableRow<Definition>, Meta>;
-    returning<Input extends SelectionInput>(this: InsertCanReturn<Definition, IsPostgres | IsSqlite>, returning: Input): Insert<SelectionRow<Input>, Meta>;
-}
-export interface OnConflict {
-    target: HasSql | Array<HasSql>;
-    targetWhere?: HasSql<boolean>;
-}
-export interface OnConflictSet<Definition extends TableDefinition> {
-    set: TableUpdate<Definition>;
-}
-export interface OnConflictUpdate<Definition extends TableDefinition> extends OnConflict, OnConflictSet<Definition> {
-    setWhere?: HasSql<boolean>;
+    returning<Meta extends IsPostgres | IsSqlite>(this: InsertCanReturn<Definition, Meta>): Insert<Array<TableRow<Definition>>, Meta>;
+    returning<Input extends SelectionInput, Meta extends IsPostgres | IsSqlite>(this: InsertCanReturn<Definition, Meta>, returning: Input): Insert<Array<SelectionRow<Input>>, Meta>;
 }
 declare class InsertCanConflict<Definition extends TableDefinition, Meta extends QueryMeta> extends InsertCanReturn<Definition, Meta> {
-    #private;
-    onConflictDoNothing(this: InsertCanConflict<Definition, IsPostgres | IsSqlite>, onConflict?: OnConflict): InsertCanReturn<Definition, Meta>;
-    onConflictDoUpdate(this: InsertCanConflict<Definition, IsPostgres | IsSqlite>, onConflict: OnConflictUpdate<Definition>): InsertCanReturn<Definition, Meta>;
-    onDuplicateKeyUpdate(this: InsertCanConflict<Definition, IsMysql>, update: OnConflictSet<Definition>): InsertCanReturn<Definition, Meta>;
+    onConflictDoNothing<Meta extends IsPostgres | IsSqlite>(this: InsertCanConflict<Definition, Meta>, onConflictDoNothing?: OnConflict): InsertCanConflict<Definition, Meta>;
+    onConflictDoUpdate<Meta extends IsPostgres | IsSqlite>(this: InsertCanConflict<Definition, Meta>, onConflict: OnConflictUpdate<Definition>): InsertCanConflict<Definition, Meta>;
+    onDuplicateKeyUpdate<Meta extends IsMysql>(this: InsertCanConflict<Definition, Meta>, onDuplicateKeyUpdate: OnConflictSet<Definition>): InsertCanConflict<Definition, Meta>;
 }
 export declare class InsertInto<Definition extends TableDefinition, Meta extends QueryMeta> {
-    [internalData]: InsertData<Meta>;
-    constructor(data: InsertData<Meta>);
+    [internalData]: QueryData<Meta> & InsertQuery;
+    constructor(data: QueryData<Meta> & InsertQuery);
     values(value: TableInsert<Definition>): InsertCanConflict<Definition, Meta>;
     values(values: Array<TableInsert<Definition>>): InsertCanConflict<Definition, Meta>;
-    select(query: Query<TableRow<Definition>, Meta>): InsertCanConflict<Definition, Meta>;
+    select(query: SingleQuery<Array<TableRow<Definition>>, Meta>): InsertCanConflict<Definition, Meta>;
 }
+export declare function insertQuery(query: InsertQuery): Sql;
 export {};

package/dist/core/query/Insert.js

@@ -1,28 +1,29 @@
 // src/core/query/Insert.ts
 import {
   getData,
-  getQuery,
   getTable,
-  hasSql,
   internalData,
   internalQuery,
   internalSelection
 } from "../Internal.js";
-import { Query } from "../Query.js";
+import { SingleQuery } from "../Queries.js";
 import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
-import { input } from "../expr/Input.js";
-var Insert = class extends Query {
+import { input, mapToColumn } from "../expr/Input.js";
+import { formatCTE } from "./CTE.js";
+import { selectQuery } from "./Select.js";
+import { formatModifiers } from "./Shared.js";
+var Insert = class extends SingleQuery {
   [internalData];
   constructor(data) {
     super(data);
     this[internalData] = data;
-    if (data.returning) this[internalSelection] = data.returning;
+    if (data.returning) this[internalSelection] = selection(data.returning);
   }
   get [internalQuery]() {
-    return sql.chunk("emitInsert", this);
+    return insertQuery(getData(this));
   }
 };
 var InsertCanReturn = class extends Insert {
@@ -30,93 +31,141 @@ var InsertCanReturn = class extends Insert {
     const data = getData(this);
     return new Insert({
       ...data,
-      returning: returning ? selection(returning) : selection.table(data.into)
+      returning: returning ?? data.insert
     });
   }
 };
-var InsertCanConflict = class extends InsertCanReturn {
-  onConflictDoNothing(onConflict) {
-    return this.#onConflict(onConflict ?? {});
+var InsertCanConflict = class _InsertCanConflict extends InsertCanReturn {
+  onConflictDoNothing(onConflictDoNothing) {
+    const { on = [], ...data } = getData(this);
+    return new _InsertCanConflict({
+      ...data,
+      on: [...on, { conflictDoNothing: onConflictDoNothing ?? true }]
+    });
   }
   onConflictDoUpdate(onConflict) {
-    return this.#onConflict(onConflict);
-  }
-  onDuplicateKeyUpdate(update) {
-    return new InsertCanReturn({
-      ...getData(this),
-      onDuplicateKeyUpdate: this.#updateFields(update.set)
+    const { on = [], ...data } = getData(this);
+    return new _InsertCanConflict({
+      ...data,
+      on: [...on, { conflictDoUpdate: onConflict }]
     });
   }
-  #updateFields(update) {
-    return sql.join(
-      Object.entries(update).map(
-        ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
-      ),
-      sql`, `
-    );
-  }
-  #onConflict({
-    target,
-    targetWhere,
-    set,
-    setWhere
-  }) {
-    const update = set && this.#updateFields(set);
-    return new InsertCanReturn({
-      ...getData(this),
-      onConflict: sql.join([
-        target && sql`(${Array.isArray(target) ? sql.join(target, sql`, `) : target})`,
-        targetWhere && sql`where ${targetWhere}`,
-        update ? sql.join([
-          sql`do update set ${update}`,
-          setWhere && sql`where ${setWhere}`
-        ]) : sql`do nothing`
-      ])
+  onDuplicateKeyUpdate(onDuplicateKeyUpdate) {
+    const { on = [], ...data } = getData(this);
+    return new _InsertCanConflict({
+      ...data,
+      on: [...on, { duplicateKeyUpdate: onDuplicateKeyUpdate }]
     });
   }
 };
-var defaultKeyword = sql.universal({
-  sqlite: sql`null`,
-  default: sql`default`
-});
 var InsertInto = class {
   [internalData];
   constructor(data) {
     this[internalData] = data;
   }
-  values(insert) {
-    const { into } = getData(this);
-    const rows = Array.isArray(insert) ? insert : [insert];
-    const table = getTable(into);
-    const values = sql.join(
-      rows.map((row) => {
-        return sql`(${sql.join(
-          Object.entries(table.columns).map(([key, column]) => {
-            const value = row[key];
-            const { $default, mapToDriverValue } = getData(column);
-            if (value !== void 0) {
-              if (value && typeof value === "object" && hasSql(value))
-                return value;
-              return input(mapToDriverValue?.(value) ?? value);
-            }
-            if ($default) return $default();
-            return defaultKeyword;
-          }),
-          sql`, `
-        )})`;
-      }),
-      sql`, `
-    );
-    return new InsertCanConflict({ ...getData(this), values });
+  values(values) {
+    return new InsertCanConflict({
+      ...getData(this),
+      values
+    });
   }
   select(query) {
     return new InsertCanConflict({
       ...getData(this),
-      select: getQuery(query)
+      ...getData(query)
     });
   }
 };
+function formatDefaultValue(value) {
+  return sql.universal({
+    sqlite: value,
+    default: sql`default`
+  });
+}
+var defaultKeyword = formatDefaultValue(sql`null`);
+function formatValues(table, rows) {
+  return sql.join(
+    rows.map((row) => {
+      return sql`(${sql.join(
+        Object.entries(table.columns).map(([key, column]) => {
+          const expr = row[key];
+          const columnApi = getData(column);
+          const { $onUpdate, $default, defaultValue } = columnApi;
+          if (expr !== void 0) return mapToColumn(columnApi, expr);
+          if ($default) return $default();
+          if (defaultValue) return formatDefaultValue(defaultValue);
+          if ($onUpdate) return $onUpdate();
+          return defaultKeyword;
+        }),
+        sql`, `
+      )})`;
+    }),
+    sql`, `
+  );
+}
+function formatUpdates(update) {
+  return sql.join(
+    Object.entries(update).map(
+      ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
+    ),
+    sql`, `
+  );
+}
+function formatConflict({
+  target,
+  targetWhere,
+  set,
+  where: setWhere
+}) {
+  const update = set && formatUpdates(set);
+  return sql.query({
+    onConflict: sql.join([
+      target && sql`(${Array.isArray(target) ? sql.join(target, sql`, `) : target})`,
+      targetWhere && sql`where ${targetWhere}`,
+      update ? sql.join([
+        sql`do update set ${update}`,
+        setWhere && sql`where ${setWhere}`
+      ]) : sql`do nothing`
+    ])
+  });
+}
+function formatConflicts(on) {
+  return sql.join(
+    on.map((conflict) => {
+      if ("duplicateKeyUpdate" in conflict)
+        return sql.query({
+          onDuplicateKeyUpdate: formatUpdates(conflict.duplicateKeyUpdate.set)
+        });
+      if ("conflictDoUpdate" in conflict)
+        return formatConflict(conflict.conflictDoUpdate);
+      if ("conflictDoNothing" in conflict)
+        return formatConflict(
+          conflict.conflictDoNothing === true ? {} : conflict.conflictDoNothing
+        );
+      throw new Error("Unknown conflict type");
+    })
+  );
+}
+function insertQuery(query) {
+  const { insert, values, select, returning } = query;
+  if (!values && !select) throw new Error("No values defined");
+  const table = getTable(insert);
+  const tableName = sql.identifier(table.name);
+  const toInsert = values ? sql.query({
+    values: formatValues(table, Array.isArray(values) ? values : [values])
+  }) : selectQuery(query);
+  const conflicts = query.on ? formatConflicts(query.on) : void 0;
+  return sql.query(
+    formatCTE(query),
+    { insertInto: sql`${tableName} (${table.listColumns()})` },
+    toInsert,
+    conflicts,
+    returning && sql.query({ returning: selection(returning) }),
+    formatModifiers(query)
+  ).inlineFields(false);
+}
 export {
   Insert,
-  InsertInto
+  InsertInto,
+  insertQuery
 };

package/dist/core/query/Query.d.ts

@@ -0,0 +1,124 @@
+import type { HasSql, HasTarget } from '../Internal.js';
+import type { MakeNullable, SelectionInput, SelectionRow } from '../Selection.js';
+import type { Sql } from '../Sql.js';
+import type { Table, TableDefinition, TableFields, TableInsert, TableUpdate } from '../Table.js';
+import type { Expand } from '../Types.js';
+import type { Input } from '../expr/Input.js';
+import type { CTE } from './CTE.js';
+export interface InnerJoin<Target> {
+    innerJoin: Target;
+    on: HasSql<boolean>;
+}
+export interface LeftJoin<Target> {
+    leftJoin: Target;
+    on: HasSql<boolean>;
+}
+export interface RightJoin<Target> {
+    rightJoin: Target;
+    on: HasSql<boolean>;
+}
+export interface FullJoin<Target> {
+    fullJoin: Target;
+    on: HasSql<boolean>;
+}
+export interface CrossJoin<Target> {
+    crossJoin: Target;
+    on: HasSql<boolean>;
+}
+export type Join<Target = HasTarget | Sql> = InnerJoin<Target> | LeftJoin<Target> | RightJoin<Target> | FullJoin<Target> | CrossJoin<Target>;
+export type JoinOp = 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin' | 'crossJoin';
+export interface QueryBase {
+    with?: Array<CTE>;
+    withRecursive?: Array<CTE>;
+}
+interface SelectBase<Returning> {
+    where?: HasSql<boolean>;
+    distinct?: boolean;
+    distinctOn?: Array<HasSql>;
+    groupBy?: Array<HasSql>;
+    having?: HasSql<boolean> | ((input: Returning) => HasSql<boolean>);
+}
+export interface ResultModifiers {
+    orderBy?: Array<HasSql>;
+    limit?: Input<number>;
+    offset?: Input<number>;
+}
+export type FromGuard<Target = HasTarget | Sql> = Target | [Target, ...Array<Join<Target>>];
+interface SelectionBase<Returning = SelectionInput> extends SelectBase<Returning> {
+    select: Returning;
+    from?: FromGuard;
+}
+export interface SelectionQuery<Returning = SelectionInput> extends SelectionBase<Returning>, QueryBase, ResultModifiers {
+}
+interface FromBase<Target = FromGuard> extends SelectBase<undefined> {
+    from: Target;
+}
+export interface FromQuery<Target> extends FromBase<Target>, QueryBase, ResultModifiers {
+}
+type FoldJoins<T extends Array<unknown>, Result> = T extends [
+    infer Join,
+    ...infer Joins
+] ? FoldJoins<Joins, Join extends LeftJoin<Table<infer Definition, infer Name>> ? Result & MakeNullable<Record<Name, TableFields<Definition>>> : Join extends RightJoin<Table<infer Definition, infer Name>> ? MakeNullable<Result> & Record<Name, TableFields<Definition>> : Join extends InnerJoin<Table<infer Definition, infer Name>> ? Result & Record<Name, TableFields<Definition>> : Join extends FullJoin<Table<infer Definition, infer Name>> ? MakeNullable<Result> & MakeNullable<Record<Name, TableFields<Definition>>> : Result> : Result;
+export type FromRow<Target> = Target extends [
+    Table<infer Definition, infer Name>,
+    ...infer Joins
+] ? Joins['length'] extends 0 ? TableFields<Definition> : Expand<FoldJoins<Joins, Record<Name, TableFields<Definition>>>> : SelectionRow<Target>;
+export type Union<Returning = SelectionInput> = {
+    union: SelectQuery<Returning>;
+} | {
+    unionAll: SelectQuery<Returning>;
+} | {
+    intersect: SelectQuery<Returning>;
+} | {
+    intersectAll: SelectQuery<Returning>;
+} | {
+    except: SelectQuery<Returning>;
+} | {
+    exceptAll: SelectQuery<Returning>;
+};
+export type UnionOp = 'union' | 'unionAll' | 'intersect' | 'intersectAll' | 'except' | 'exceptAll';
+export type CompoundSelect<Returning = SelectionInput> = [
+    SelectQuery<Returning>,
+    ...Array<Union<Returning>>
+];
+export interface UnionQuery<Returning = SelectionInput> extends QueryBase, ResultModifiers {
+    select: CompoundSelect<Returning>;
+}
+export interface SelectQuery<Returning = SelectionInput> extends SelectionQuery<Returning> {
+}
+export interface OnConflict {
+    target: HasSql | Array<HasSql>;
+    targetWhere?: HasSql<boolean>;
+}
+export interface OnConflictSet<Definition extends TableDefinition> {
+    set: TableUpdate<Definition>;
+}
+export interface OnConflictUpdate<Definition extends TableDefinition> extends OnConflict, OnConflictSet<Definition> {
+    where?: HasSql<boolean>;
+}
+export type Conflict<Definition extends TableDefinition = TableDefinition> = {
+    conflictDoNothing: true | OnConflict;
+} | {
+    conflictDoUpdate: OnConflictUpdate<Definition>;
+} | {
+    duplicateKeyUpdate: OnConflictSet<Definition>;
+};
+export interface InsertQuery<Returning = SelectionInput, Definition extends TableDefinition = TableDefinition> extends Partial<SelectionQuery<Returning>>, QueryBase, ResultModifiers {
+    insert: Table<Definition>;
+    values?: TableInsert<Definition> | Array<TableInsert<Definition>>;
+    returning?: Returning;
+    on?: Array<Conflict<Definition>>;
+}
+export interface DeleteQuery<Returning = SelectionInput, Definition extends TableDefinition = TableDefinition> extends QueryBase, ResultModifiers {
+    delete: Table<Definition>;
+    where?: HasSql<boolean>;
+    returning?: Returning;
+}
+export interface UpdateQuery<Returning = SelectionInput, Definition extends TableDefinition = TableDefinition> extends QueryBase, ResultModifiers {
+    update: Table<Definition>;
+    set?: TableUpdate<Definition>;
+    where?: HasSql<boolean>;
+    returning?: Returning;
+}
+export type Query<Returning = SelectionInput> = SelectionQuery<Returning> | FromQuery<Returning> | InsertQuery<Returning> | DeleteQuery<Returning> | UpdateQuery<Returning>;
+export {};