rado 0.2.23 → 0.2.25

package/dist/define/query/Select.d.ts

@@ -0,0 +1,41 @@
+import { EV, Expr } from '../Expr';
+import { OrderBy } from '../OrderBy';
+import { Query, QueryData } from '../Query';
+import { Selection } from '../Selection';
+import { Table } from '../Table';
+import { TableSelect } from './TableSelect';
+import { Union } from './Union';
+export declare class SelectMultiple<Row> extends Union<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any>): SelectMultiple<Row>;
+    leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
+    innerJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
+    select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
+    count(): SelectSingle<number>;
+    orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<Row>;
+    maybeFirst(): SelectSingle<Row | undefined>;
+    first(): SelectSingle<Row>;
+    where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
+    take(limit: number | undefined): SelectMultiple<Row>;
+    skip(offset: number | undefined): SelectMultiple<Row>;
+    recursiveUnion<T extends {}>(this: SelectMultiple<T>, create: (fields: Record<string, Table.Of<T>>) => SelectMultiple<T> | Union<T>): SelectMultiple<T>;
+    recursiveUnionAll<T extends {}>(this: SelectMultiple<T>, create: (fields: Record<string, Table.Of<T>>) => SelectMultiple<T> | Union<T>): SelectMultiple<T>;
+    [Expr.ToExpr](): Expr<Row>;
+}
+export declare class SelectSingle<Row> extends Query<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any>): SelectMultiple<Row>;
+    leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
+    innerJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
+    select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
+    orderBy(...orderBy: Array<OrderBy>): SelectSingle<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): SelectSingle<Row>;
+    where(...where: Array<EV<boolean>>): SelectSingle<Row>;
+    take(limit: number | undefined): SelectSingle<Row>;
+    skip(offset: number | undefined): SelectSingle<Row>;
+    all(): SelectMultiple<Row>;
+    [Expr.ToExpr](): Expr<Row>;
+}

package/dist/define/query/Select.js

@@ -0,0 +1,190 @@
+// src/define/query/Select.ts
+import { makeRecursiveUnion } from "../CTE.js";
+import { Expr, ExprData } from "../Expr.js";
+import { Functions } from "../Functions.js";
+import { Query, QueryData } from "../Query.js";
+import { Table } from "../Table.js";
+import { Target } from "../Target.js";
+import { Union } from "./Union.js";
+function joinTarget(joinType, query, to, on) {
+  const toQuery = Query.isQuery(to) ? to[Query.Data] : void 0;
+  const target = toQuery ? toQuery.from : new Target.Table(to[Table.Data]);
+  if (!query.from || !target)
+    throw new Error("No from clause");
+  const conditions = [...on];
+  if (toQuery) {
+    const where = toQuery.where;
+    if (where)
+      conditions.push(new Expr(where));
+  }
+  return new Target.Join(
+    query.from,
+    target,
+    joinType,
+    Expr.and(...conditions)[Expr.Data]
+  );
+}
+var SelectMultiple = class extends Union {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    return new SelectMultiple(
+      this[Query.Data].with({ from: new Target.Table(table) })
+    );
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectMultiple(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectMultiple(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new SelectMultiple(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  count() {
+    return new SelectSingle(
+      this[Query.Data].with({
+        selection: Functions.count()[Expr.Data],
+        singleResult: true
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new SelectMultiple(
+      this[Query.Data].with({
+        orderBy: orderBy.map((e) => {
+          return Expr.isExpr(e) ? e.asc() : e;
+        })
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new SelectMultiple(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  maybeFirst() {
+    return new SelectSingle(this[Query.Data].with({ singleResult: true }));
+  }
+  first() {
+    return new SelectSingle(
+      this[Query.Data].with({
+        singleResult: true,
+        validate: true
+      })
+    );
+  }
+  where(...where) {
+    return new SelectMultiple(this.addWhere(where));
+  }
+  take(limit) {
+    return new SelectMultiple(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new SelectMultiple(this[Query.Data].with({ offset }));
+  }
+  recursiveUnion(create) {
+    return new SelectMultiple(
+      makeRecursiveUnion(
+        this[Query.Data],
+        create,
+        QueryData.UnionOperation.Union
+      )
+    );
+  }
+  recursiveUnionAll(create) {
+    return new SelectMultiple(
+      makeRecursiveUnion(
+        this[Query.Data],
+        create,
+        QueryData.UnionOperation.UnionAll
+      )
+    );
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+};
+var SelectSingle = class extends Query {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    return new SelectMultiple(
+      this[Query.Data].with({ from: new Target.Table(table) })
+    );
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectSingle(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectSingle(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new SelectSingle(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new SelectSingle(
+      this[Query.Data].with({
+        orderBy
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new SelectSingle(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  where(...where) {
+    return new SelectSingle(this.addWhere(where));
+  }
+  take(limit) {
+    return new SelectSingle(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new SelectSingle(this[Query.Data].with({ offset }));
+  }
+  all() {
+    return new SelectMultiple(this[Query.Data].with({ singleResult: false }));
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+};
+export {
+  SelectMultiple,
+  SelectSingle
+};

package/dist/define/query/TableSelect.d.ts

@@ -0,0 +1,21 @@
+import { EV, Expr } from '../Expr';
+import { Query, QueryData } from '../Query';
+import { Table, TableData } from '../Table';
+import { CreateTable } from './CreateTable';
+import { Delete } from './Delete';
+import { Inserted } from './Insert';
+import { SelectMultiple } from './Select';
+import { Update } from './Update';
+export declare class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
+    protected table: TableData;
+    [Query.Data]: QueryData.Select;
+    constructor(table: TableData, conditions?: Array<EV<boolean>>);
+    as(alias: string): Table<Definition>;
+    create(): CreateTable;
+    insertSelect(query: SelectMultiple<Table.Insert<Definition>>): Inserted;
+    insertOne(record: Table.Insert<Definition>): Query<Table.Select<Definition>>;
+    insertAll(data: Array<Table.Insert<Definition>>): Inserted;
+    set(data: Table.Update<Definition>): Update<Definition>;
+    delete(): Delete;
+    get(name: string): Expr<any>;
+}

package/dist/define/query/TableSelect.js

@@ -0,0 +1,71 @@
+// src/define/query/TableSelect.ts
+import { Expr, ExprData } from "../Expr.js";
+import { Query, QueryData } from "../Query.js";
+import { createTable } from "../Table.js";
+import { Target } from "../Target.js";
+import { CreateTable } from "./CreateTable.js";
+import { Delete } from "./Delete.js";
+import { Insert, Inserted } from "./Insert.js";
+import { SelectMultiple } from "./Select.js";
+import { Update } from "./Update.js";
+var TableSelect = class extends SelectMultiple {
+  constructor(table, conditions = []) {
+    const target = new Target.Table(table);
+    super(
+      new QueryData.Select({
+        from: target,
+        selection: new ExprData.Row(target),
+        where: Expr.and(...conditions)[Expr.Data]
+      })
+    );
+    this.table = table;
+  }
+  as(alias) {
+    return createTable({ ...this.table, alias });
+  }
+  create() {
+    return new CreateTable(this.table);
+  }
+  insertSelect(query) {
+    return new Inserted(
+      new QueryData.Insert({ into: this.table, select: query[Query.Data] })
+    );
+  }
+  insertOne(record) {
+    return new Query(
+      new QueryData.Insert({
+        into: this.table,
+        data: [record],
+        selection: new ExprData.Row(new Target.Table(this.table)),
+        singleResult: true
+      })
+    );
+  }
+  insertAll(data) {
+    return new Insert(this.table).values(...data);
+  }
+  set(data) {
+    return new Update(
+      new QueryData.Update({
+        table: this.table,
+        where: this[Query.Data].where
+      })
+    ).set(data);
+  }
+  delete() {
+    return new Delete(
+      new QueryData.Delete({
+        table: this.table,
+        where: this[Query.Data].where
+      })
+    );
+  }
+  get(name) {
+    return new Expr(
+      new ExprData.Field(new ExprData.Row(new Target.Table(this.table)), name)
+    );
+  }
+};
+export {
+  TableSelect
+};

package/dist/define/query/Union.d.ts

@@ -0,0 +1,10 @@
+import { Query, QueryData } from '../Query';
+import { SelectMultiple } from './Select';
+export declare class Union<Row> extends Query<Array<Row>> {
+    [Query.Data]: QueryData.Union | QueryData.Select;
+    constructor(query: QueryData.Union | QueryData.Select);
+    union(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
+    unionAll(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
+    except(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
+    intersect(query: SelectMultiple<Row> | Union<Row>): Union<Row>;
+}

package/dist/define/query/Union.js

@@ -0,0 +1,46 @@
+// src/define/query/Union.ts
+import { Query, QueryData } from "../Query.js";
+var Union = class extends Query {
+  constructor(query) {
+    super(query);
+  }
+  union(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.Union,
+        b: query[Query.Data]
+      })
+    );
+  }
+  unionAll(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.UnionAll,
+        b: query[Query.Data]
+      })
+    );
+  }
+  except(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.Except,
+        b: query[Query.Data]
+      })
+    );
+  }
+  intersect(query) {
+    return new Union(
+      new QueryData.Union({
+        a: this[Query.Data],
+        operator: QueryData.UnionOperation.Intersect,
+        b: query[Query.Data]
+      })
+    );
+  }
+};
+export {
+  Union
+};

package/dist/define/query/Update.d.ts

@@ -0,0 +1,12 @@
+import { EV } from '../Expr';
+import { Query, QueryData } from '../Query';
+import { Table } from '../Table';
+export declare class Update<Definition> extends Query<{
+    rowsAffected: number;
+}> {
+    [Query.Data]: QueryData.Update;
+    set(set: Table.Update<Definition>): Update<Definition>;
+    where(...where: Array<EV<boolean>>): Update<Definition>;
+    take(limit: number | undefined): Update<Definition>;
+    skip(offset: number | undefined): Update<Definition>;
+}

package/dist/define/query/Update.js

@@ -0,0 +1,19 @@
+// src/define/query/Update.ts
+import { Query } from "../Query.js";
+var Update = class extends Query {
+  set(set) {
+    return new Update(this[Query.Data].with({ set }));
+  }
+  where(...where) {
+    return new Update(this.addWhere(where));
+  }
+  take(limit) {
+    return new Update(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new Update(this[Query.Data].with({ offset }));
+  }
+};
+export {
+  Update
+};

package/dist/driver/bun-sqlite.js

@@ -1,5 +1,6 @@
 // src/driver/bun-sqlite.ts
-import { Query, QueryData } from "../define/Query.js";
+import { QueryData } from "../define/Query.js";
+import { SelectSingle } from "../define/query/Select.js";
 import { Driver } from "../lib/Driver.js";
 import { SqlError } from "../lib/SqlError.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
@@ -34,7 +35,7 @@ var BunSqliteDriver = class extends Driver.Sync {
     this.tableData = this.prepare(SqliteSchema.tableData);
     this.indexData = this.prepare(SqliteSchema.indexData);
     this.lastChanges = this.prepare(() => {
-      return new Query.SelectSingle(
+      return new SelectSingle(
         new QueryData.Raw({
           expectedReturn: "row",
           strings: ["SELECT changes() as rowsAffected"],

package/dist/driver/sql.js.d.ts

@@ -5,8 +5,8 @@ import { Statement } from '../lib/Statement';
 import { SqliteSchema } from '../sqlite/SqliteSchema';
 export declare class SqlJsDriver extends Driver.Sync {
     db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    tableData?: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData?: (tableName: string) => Array<SqliteSchema.Index>;
     constructor(db: Database);
     prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
     schemaInstructions(tableName: string): SchemaInstructions | undefined;

package/dist/driver/sql.js.js

@@ -38,8 +38,6 @@ var SqlJsDriver = class extends Driver.Sync {
   constructor(db) {
     super(new SqliteFormatter());
     this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
   }
   tableData;
   indexData;
@@ -55,6 +53,8 @@ var SqlJsDriver = class extends Driver.Sync {
     }
   }
   schemaInstructions(tableName) {
+    this.tableData = this.tableData || (this.tableData = this.prepare(SqliteSchema.tableData));
+    this.indexData = this.indexData || (this.indexData = this.prepare(SqliteSchema.indexData));
     const columnData = this.tableData(tableName);
     const indexData = this.indexData(tableName);
     return SqliteSchema.createInstructions(columnData, indexData);

package/dist/lib/Driver.d.ts

@@ -2,6 +2,7 @@ import { Expr } from '../define/Expr';
 import { Query, QueryData } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 import { Table } from '../define/Table';
+import { SelectMultiple } from '../define/query/Select';
 import { Callable } from '../util/Callable';
 import { Formatter } from './Formatter';
 import { Statement } from './Statement';
@@ -9,8 +10,6 @@ declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
     compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): [QueryData, Statement];
-    all(...args: Array<any>): any;
-    get(...args: Array<any>): any;
     executeTemplate(expectedReturn: QueryData.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
     abstract executeQuery(query: QueryData): any;
 }
@@ -32,13 +31,7 @@ declare abstract class SyncDriver extends DriverBase {
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => R;
     migrateSchema(...tables: Array<Table<any>>): unknown;
     executeQuery(query: QueryData, stmt?: SyncPreparedStatement, params?: Array<any>): unknown;
-    all<T>(cursor: Query.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Query<T>): T;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    get<T>(cursor: Query.SelectMultiple<T>): T | null;
-    get<T>(cursor: Query<T>): T;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-    iterate<T>(cursor: Query.SelectMultiple<T>): Iterable<T>;
+    iterate<T>(cursor: SelectMultiple<T>): Iterable<T>;
     transaction<T>(run: (query: SyncDriver) => T): T;
     toAsync(): SyncWrapper;
 }
@@ -65,13 +58,7 @@ declare abstract class AsyncDriver extends DriverBase {
     prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Query<R>): (...params: ParamTypes<T>) => Promise<R>;
     migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
     executeQuery(query: QueryData, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<unknown>;
-    all<T>(cursor: Query.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Query<T>): Promise<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-    get<T>(cursor: Query.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Query<T>): Promise<T>;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-    iterate<T>(cursor: Query.SelectMultiple<T>): AsyncIterable<T>;
+    iterate<T>(cursor: SelectMultiple<T>): AsyncIterable<T>;
     transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
 }
 declare class SyncWrapper extends AsyncDriver {

package/dist/lib/Driver.js

@@ -34,22 +34,6 @@ var DriverBase = class extends Callable {
     const query = cursor[Query.Data];
     return [query, this.formatter.compile(query)];
   }
-  all(...args) {
-    const [input, ...rest] = args;
-    if (Query.isSingle(input))
-      return this.executeQuery(input.all()[Query.Data]);
-    if (Query.isQuery(input))
-      return this.executeQuery(input[Query.Data]);
-    return this.executeTemplate("rows", input, ...rest);
-  }
-  get(...args) {
-    const [input, ...rest] = args;
-    if (Query.isMultiple(input))
-      return this.executeQuery(input.maybeFirst()[Query.Data]);
-    if (Query.isQuery(input))
-      return this.executeQuery(input[Query.Data]);
-    return this.executeTemplate("row", input, ...rest);
-  }
   executeTemplate(expectedReturn, strings, ...params) {
     return this.executeQuery(
       new QueryData.Raw({ strings, params, expectedReturn })
@@ -109,7 +93,7 @@ var SyncDriver = class extends DriverBase {
         const compiled = stmt ? void 0 : this.formatter.compile(query);
         stmt = stmt || this.prepareStatement(compiled, true);
         params = params || compiled.params();
-        if ("selection" in query) {
+        if ("selection" in query || query.type === QueryType.Union) {
           const res = stmt.all(params).map((row) => JSON.parse(row.result).result);
           if (query.singleResult) {
             const row = res[0];
@@ -133,12 +117,6 @@ var SyncDriver = class extends DriverBase {
         }
     }
   }
-  all(...args) {
-    return super.all(...args);
-  }
-  get(...args) {
-    return super.get(...args);
-  }
   *iterate(cursor) {
     const stmt = this.prepareStatement(
       this.formatter.compile(cursor[Query.Data]),
@@ -229,7 +207,7 @@ var AsyncDriver = class extends DriverBase {
         const compiled = stmt ? void 0 : this.formatter.compile(query);
         stmt = stmt || this.prepareStatement(compiled, true);
         params = params || compiled.params();
-        if ("selection" in query) {
+        if ("selection" in query || query.type === QueryType.Union) {
           const res = (await stmt.all(params)).map(
             (item) => JSON.parse(item.result).result
           );
@@ -255,12 +233,6 @@ var AsyncDriver = class extends DriverBase {
         }
     }
   }
-  all(...args) {
-    return super.all(...args);
-  }
-  get(...args) {
-    return super.get(...args);
-  }
   async *iterate(cursor) {
     const stmt = this.prepareStatement(
       this.formatter.compile(cursor[Query.Data]),

package/dist/lib/Formatter.d.ts

@@ -49,6 +49,7 @@ export declare abstract class Formatter implements Sanitizer {
     };
     format(ctx: FormatContext, query: QueryData): Statement;
     formatSelect({ topLevel, ...ctx }: FormatContext, query: QueryData.Select): Statement;
+    formatUnion(ctx: FormatContext, { a, operator, b }: QueryData.Union): Statement;
     formatInsert(ctx: FormatContext, query: QueryData.Insert): Statement;
     formatUpdate(ctx: FormatContext, query: QueryData.Update): Statement;
     formatDelete(ctx: FormatContext, query: QueryData.Delete): Statement;

package/dist/lib/Formatter.js

@@ -31,6 +31,12 @@ var joins = {
   left: "LEFT",
   inner: "INNER"
 };
+var unions = {
+  [QueryData.UnionOperation.Union]: "UNION",
+  [QueryData.UnionOperation.UnionAll]: "UNION ALL",
+  [QueryData.UnionOperation.Intersect]: "INTERSECT",
+  [QueryData.UnionOperation.Except]: "EXCEPT"
+};
 function formatAsResultObject(stmt, mkSubject) {
   stmt.raw("json_object('result', ");
   mkSubject();
@@ -53,6 +59,8 @@ var Formatter = class {
     switch (query.type) {
       case QueryType.Select:
         return this.formatSelect(ctx, query);
+      case QueryType.Union:
+        return this.formatUnion(ctx, query);
       case QueryType.Insert:
         return this.formatInsert(ctx, query);
       case QueryType.Update:
@@ -79,21 +87,38 @@ var Formatter = class {
   }
   formatSelect({ topLevel, ...ctx }, query) {
     const { stmt } = ctx;
-    stmt.raw("SELECT").space();
-    this.formatSelection(
-      ctx,
-      query.selection,
-      topLevel ? formatAsResultObject : void 0
-    );
-    if (query.from) {
-      stmt.addLine("FROM").space();
-      this.formatTarget(ctx, query.from);
+    switch (query.from?.type) {
+      case TargetType.CTE:
+        stmt.add("WITH RECURSIVE").addIdentifier(query.from.name).add("AS").space().openParenthesis();
+        this.formatUnion(
+          { ...ctx, topLevel: false, selectAsColumns: true },
+          query.from.union
+        );
+        stmt.closeParenthesis().space();
+      default:
+        stmt.raw("SELECT").space();
+        this.formatSelection(
+          ctx,
+          query.selection,
+          topLevel ? formatAsResultObject : void 0
+        );
+        if (query.from) {
+          stmt.addLine("FROM").space();
+          this.formatTarget(ctx, query.from);
+        }
+        this.formatWhere(ctx, query.where);
+        this.formatGroupBy(ctx, query.groupBy);
+        this.formatHaving(ctx, query.having);
+        this.formatOrderBy(ctx, query.orderBy);
+        this.formatLimit(ctx, query);
+        return stmt;
     }
-    this.formatWhere(ctx, query.where);
-    this.formatGroupBy(ctx, query.groupBy);
-    this.formatHaving(ctx, query.having);
-    this.formatOrderBy(ctx, query.orderBy);
-    this.formatLimit(ctx, query);
+  }
+  formatUnion(ctx, { a, operator, b }) {
+    const { stmt } = ctx;
+    this.format(ctx, a);
+    stmt.add(unions[operator]).space();
+    this.format(ctx, b);
     return stmt;
   }
   formatInsert(ctx, query) {
@@ -377,6 +402,8 @@ var Formatter = class {
         if (target.alias)
           stmt.add("AS").addIdentifier(target.alias);
         return stmt;
+      case TargetType.CTE:
+        return stmt.addIdentifier(target.name);
       case TargetType.Expr:
         throw new Error("Cannot format expression as target");
     }
@@ -685,6 +712,7 @@ var Formatter = class {
       const inner = { ...ctx, selectAsColumns: false };
       for (const [key, value] of stmt.separate(Object.entries(expr.fields))) {
         this.formatExprJson(inner, value);
+        stmt.add("AS").addIdentifier(key);
       }
       return stmt;
     }