rado 0.2.23 → 0.2.24

package/dist/define/CTE.d.ts

@@ -0,0 +1,2 @@
+import { Query, QueryData } from './Query';
+export declare function makeRecursiveUnion<T extends Query<any>>(initial: QueryData.Select, createUnion: (target: any) => T, operator: QueryData.UnionOperation): QueryData.Select;

package/dist/define/CTE.js

@@ -0,0 +1,51 @@
+// src/define/CTE.ts
+import { Expr, ExprData, ExprType } from "./Expr.js";
+import { Query, QueryData } from "./Query.js";
+import { virtualTable } from "./Table.js";
+import { Target, TargetType } from "./Target.js";
+var { keys, create, fromEntries } = Object;
+function columnsOf(expr) {
+  switch (expr.type) {
+    case ExprType.Record:
+      return keys(expr.fields);
+    case ExprType.Row:
+      switch (expr.target.type) {
+        case TargetType.Table:
+          return keys(expr.target.table.columns);
+        default:
+          throw new Error("Could not retrieve CTE columns");
+      }
+    default:
+      throw new Error("Could not retrieve CTE columns");
+  }
+}
+function makeRecursiveUnion(initial, createUnion, operator) {
+  let name;
+  const alias = new Proxy(create(null), {
+    get(_, key) {
+      name = key;
+      return virtualTable(name);
+    }
+  });
+  const right = createUnion(alias)[Query.Data];
+  if (!name)
+    throw new TypeError("No CTE name provided");
+  const cte = alias[name];
+  const cols = columnsOf(initial.selection);
+  const selection = new ExprData.Record(
+    fromEntries(cols.map((col) => [col, cte[col][Expr.Data]]))
+  );
+  const union = new QueryData.Union({
+    a: initial,
+    operator,
+    b: right
+  });
+  const from = new Target.CTE(name, union);
+  return new QueryData.Select({
+    selection,
+    from
+  });
+}
+export {
+  makeRecursiveUnion
+};

package/dist/define/Functions.js

@@ -1,7 +1,9 @@
 // src/define/Functions.ts
 import { Expr, ExprData } from "./Expr.js";
-function get(_, method) {
-  return (...args) => {
+function get(target, method) {
+  if (method in target)
+    return target[method];
+  return target[method] = (...args) => {
     return new Expr(new ExprData.Call(method, args.map(ExprData.create)));
   };
 }

package/dist/define/Query.d.ts

@@ -11,6 +11,7 @@ declare const DATA: unique symbol;
 export declare enum QueryType {
     Insert = "QueryData.Insert",
     Select = "QueryData.Select",
+    Union = "QueryData.Union",
     Update = "QueryData.Update",
     Delete = "QueryData.Delete",
     CreateTable = "QueryData.CreateTable",
@@ -22,7 +23,7 @@ export declare enum QueryType {
     Transaction = "QueryData.Transaction",
     Raw = "QueryData.Raw"
 }
-export type QueryData = QueryData.Insert | QueryData.Select | QueryData.Update | QueryData.Delete | QueryData.CreateTable | QueryData.AlterTable | QueryData.DropTable | QueryData.CreateIndex | QueryData.DropIndex | QueryData.Batch | QueryData.Transaction | QueryData.Raw;
+export type QueryData = QueryData.Insert | QueryData.Select | QueryData.Union | QueryData.Update | QueryData.Delete | QueryData.CreateTable | QueryData.AlterTable | QueryData.DropTable | QueryData.CreateIndex | QueryData.DropIndex | QueryData.Batch | QueryData.Transaction | QueryData.Raw;
 export declare namespace QueryData {
     abstract class Data<T> {
         abstract type: QueryType;
@@ -35,12 +36,29 @@ export declare namespace QueryData {
         selection?: ExprData;
         singleResult?: boolean;
         validate?: boolean;
-        constructor(data: Omit<T, 'type'>);
+        constructor(data: Omit<T, 'type' | 'with'>);
+        with(data: Partial<T>): any;
+    }
+    export enum UnionOperation {
+        Union = "Union",
+        UnionAll = "UnionAll",
+        Intersect = "Intersect",
+        Except = "Except"
+    }
+    export class Union extends Data<Union> {
+        type: QueryType.Union;
+        a: Select | Union;
+        operator: UnionOperation;
+        b: Select | Union;
     }
     export class Select extends Data<Select> {
         type: QueryType.Select;
         selection: ExprData;
         from?: Target;
+        union?: Select;
+        unionAll?: Select;
+        intersect?: Select;
+        except?: Select;
     }
     export class Insert extends Data<Insert> {
         type: QueryType.Insert;
@@ -113,7 +131,7 @@ export declare namespace QueryData {
         expectedReturn?: 'row' | 'rows';
         strings: ReadonlyArray<string>;
         params: Array<any>;
-        constructor(data: Omit<Raw, 'type'>);
+        constructor(data: Omit<Raw, 'type' | 'with'>);
     }
     export {};
 }
@@ -171,9 +189,17 @@ export declare namespace Query {
         constructor(queries: Array<QueryData>);
         next<T>(cursor: Query<T>): Query<T>;
     }
-    class SelectMultiple<Row> extends Query<Array<Row>> {
+    class Union<Row> extends Query<Array<Row>> {
+        [DATA]: 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>;
+    }
+    class SelectMultiple<Row> extends Union<Row> {
         [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>>;
@@ -185,6 +211,8 @@ export declare namespace Query {
         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>;
     }
     class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
@@ -203,6 +231,7 @@ export declare namespace Query {
     class SelectSingle<Row> extends Query<Row> {
         [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>>;

package/dist/define/Query.js

@@ -1,14 +1,16 @@
 // src/define/Query.ts
+import { makeRecursiveUnion } from "./CTE.js";
 import { Expr, ExprData } from "./Expr.js";
 import { Functions } from "./Functions.js";
 import { Schema } from "./Schema.js";
-import { Table, createTable } from "./Table.js";
+import { createTable, Table } from "./Table.js";
 import { Target } from "./Target.js";
 var { assign } = Object;
 var DATA = Symbol("Query.Data");
 var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Insert"] = "QueryData.Insert";
   QueryType2["Select"] = "QueryData.Select";
+  QueryType2["Union"] = "QueryData.Union";
   QueryType2["Update"] = "QueryData.Update";
   QueryType2["Delete"] = "QueryData.Delete";
   QueryType2["CreateTable"] = "QueryData.CreateTable";
@@ -27,7 +29,21 @@ var QueryData;
     constructor(data) {
       assign(this, data);
     }
+    with(data) {
+      return new this.constructor({ ...this, ...data });
+    }
+  }
+  let UnionOperation;
+  ((UnionOperation2) => {
+    UnionOperation2["Union"] = "Union";
+    UnionOperation2["UnionAll"] = "UnionAll";
+    UnionOperation2["Intersect"] = "Intersect";
+    UnionOperation2["Except"] = "Except";
+  })(UnionOperation = QueryData2.UnionOperation || (QueryData2.UnionOperation = {}));
+  class Union extends Data {
+    type = "QueryData.Union" /* Union */;
   }
+  QueryData2.Union = Union;
   class Select extends Data {
     type = "QueryData.Select" /* Select */;
   }
@@ -100,9 +116,11 @@ var Query = class {
   }
   next(cursor) {
     return new Query(
-      new QueryData.Batch({
-        queries: [this[DATA], cursor[DATA]]
-      })
+      new QueryData.Batch(
+        this[DATA].with({
+          queries: [this[DATA], cursor[DATA]]
+        })
+      )
     );
   }
   on(driver) {
@@ -119,36 +137,33 @@ function addWhere(query, where) {
   const conditions = where.slice();
   if (query.where)
     conditions.push(new Expr(query.where));
-  return {
-    ...query,
-    where: Expr.and(...conditions)[Expr.Data]
-  };
+  return Expr.and(...conditions)[Expr.Data];
 }
 ((Query2) => {
   class Delete extends Query2 {
     where(...where) {
-      return new Delete(addWhere(this[DATA], where));
+      return new Delete(this[DATA].with({ where: addWhere(this[DATA], where) }));
     }
     take(limit) {
-      return new Delete({ ...this[DATA], limit });
+      return new Delete(this[DATA].with({ limit }));
     }
     skip(offset) {
-      return new Delete({ ...this[DATA], offset });
+      return new Delete(this[DATA].with({ offset }));
     }
   }
   Query2.Delete = Delete;
   class Update extends Query2 {
     set(set) {
-      return new Update({ ...this[DATA], set });
+      return new Update(this[DATA].with({ set }));
     }
     where(...where) {
-      return new Update(addWhere(this[DATA], where));
+      return new Update(this[DATA].with({ where: addWhere(this[DATA], where) }));
     }
     take(limit) {
-      return new Update({ ...this[DATA], limit });
+      return new Update(this[DATA].with({ limit }));
     }
     skip(offset) {
-      return new Update({ ...this[DATA], offset });
+      return new Update(this[DATA].with({ offset }));
     }
   }
   Query2.Update = Update;
@@ -204,6 +219,45 @@ function addWhere(query, where) {
     }
   }
   Query2.Batch = Batch;
+  class Union extends Query2 {
+    union(query) {
+      return new Union(
+        new QueryData.Union({
+          a: this[DATA],
+          operator: "Union" /* Union */,
+          b: query[DATA]
+        })
+      );
+    }
+    unionAll(query) {
+      return new Union(
+        new QueryData.Union({
+          a: this[DATA],
+          operator: "UnionAll" /* UnionAll */,
+          b: query[DATA]
+        })
+      );
+    }
+    except(query) {
+      return new Union(
+        new QueryData.Union({
+          a: this[DATA],
+          operator: "Except" /* Except */,
+          b: query[DATA]
+        })
+      );
+    }
+    intersect(query) {
+      return new Union(
+        new QueryData.Union({
+          a: this[DATA],
+          operator: "Intersect" /* Intersect */,
+          b: query[DATA]
+        })
+      );
+    }
+  }
+  Query2.Union = Union;
   function joinTarget(joinType, query, to, on) {
     const toQuery = Query2.isQuery(to) ? to[DATA] : void 0;
     const target = toQuery ? toQuery.from : new Target.Table(to[Table.Data]);
@@ -222,69 +276,99 @@ function addWhere(query, where) {
       Expr.and(...conditions)[Expr.Data]
     );
   }
-  class SelectMultiple extends Query2 {
+  class SelectMultiple extends Union {
     constructor(query) {
       super(query);
     }
+    from(table) {
+      return new SelectMultiple(
+        this[DATA].with({ from: new Target.Table(table) })
+      );
+    }
     leftJoin(that, ...on) {
       const query = this[DATA];
-      return new SelectMultiple({
-        ...query,
-        from: joinTarget("left", query, that, on)
-      });
+      return new SelectMultiple(
+        this[DATA].with({
+          from: joinTarget("left", query, that, on)
+        })
+      );
     }
     innerJoin(that, ...on) {
       const query = this[DATA];
-      return new SelectMultiple({
-        ...query,
-        from: joinTarget("inner", query, that, on)
-      });
+      return new SelectMultiple(
+        this[DATA].with({
+          from: joinTarget("inner", query, that, on)
+        })
+      );
     }
     select(selection) {
-      return new SelectMultiple({
-        ...this[DATA],
-        selection: ExprData.create(selection)
-      });
+      return new SelectMultiple(
+        this[DATA].with({
+          selection: ExprData.create(selection)
+        })
+      );
     }
     count() {
-      return new SelectSingle({
-        ...this[DATA],
-        selection: Functions.count()[Expr.Data],
-        singleResult: true
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          selection: Functions.count()[Expr.Data],
+          singleResult: true
+        })
+      );
     }
     orderBy(...orderBy) {
-      return new SelectMultiple({
-        ...this[DATA],
-        orderBy: orderBy.map((e) => {
-          return Expr.isExpr(e) ? e.asc() : e;
+      return new SelectMultiple(
+        this[DATA].with({
+          orderBy: orderBy.map((e) => {
+            return Expr.isExpr(e) ? e.asc() : e;
+          })
         })
-      });
+      );
     }
     groupBy(...groupBy) {
-      return new SelectMultiple({
-        ...this[DATA],
-        groupBy: groupBy.map(ExprData.create)
-      });
+      return new SelectMultiple(
+        this[DATA].with({
+          groupBy: groupBy.map(ExprData.create)
+        })
+      );
     }
     maybeFirst() {
-      return new SelectSingle({ ...this[DATA], singleResult: true });
+      return new SelectSingle(this[DATA].with({ singleResult: true }));
     }
     first() {
-      return new SelectSingle({
-        ...this[DATA],
-        singleResult: true,
-        validate: true
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          singleResult: true,
+          validate: true
+        })
+      );
     }
     where(...where) {
-      return new SelectMultiple(addWhere(this[DATA], where));
+      return new SelectMultiple(
+        this[DATA].with({
+          where: addWhere(this[DATA], where)
+        })
+      );
     }
     take(limit) {
-      return new SelectMultiple({ ...this[DATA], limit });
+      return new SelectMultiple(this[DATA].with({ limit }));
     }
     skip(offset) {
-      return new SelectMultiple({ ...this[DATA], offset });
+      return new SelectMultiple(this[DATA].with({ offset }));
+    }
+    recursiveUnion(create) {
+      return new SelectMultiple(
+        makeRecursiveUnion(this[DATA], create, "Union" /* Union */)
+      );
+    }
+    recursiveUnionAll(create) {
+      return new SelectMultiple(
+        makeRecursiveUnion(
+          this[DATA],
+          create,
+          "UnionAll" /* UnionAll */
+        )
+      );
     }
     [Expr.ToExpr]() {
       return new Expr(new ExprData.Query(this[DATA]));
@@ -354,49 +438,63 @@ function addWhere(query, where) {
     constructor(query) {
       super(query);
     }
+    from(table) {
+      return new SelectMultiple(
+        this[DATA].with({ from: new Target.Table(table) })
+      );
+    }
     leftJoin(that, ...on) {
       const query = this[DATA];
-      return new SelectSingle({
-        ...query,
-        from: joinTarget("left", query, that, on)
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          from: joinTarget("left", query, that, on)
+        })
+      );
     }
     innerJoin(that, ...on) {
       const query = this[DATA];
-      return new SelectSingle({
-        ...query,
-        from: joinTarget("inner", query, that, on)
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          from: joinTarget("inner", query, that, on)
+        })
+      );
     }
     select(selection) {
-      return new SelectSingle({
-        ...this[DATA],
-        selection: ExprData.create(selection)
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          selection: ExprData.create(selection)
+        })
+      );
     }
     orderBy(...orderBy) {
-      return new SelectSingle({
-        ...this[DATA],
-        orderBy
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          orderBy
+        })
+      );
     }
     groupBy(...groupBy) {
-      return new SelectSingle({
-        ...this[DATA],
-        groupBy: groupBy.map(ExprData.create)
-      });
+      return new SelectSingle(
+        this[DATA].with({
+          groupBy: groupBy.map(ExprData.create)
+        })
+      );
     }
     where(...where) {
-      return new SelectSingle(addWhere(this[DATA], where));
+      return new SelectSingle(
+        this[DATA].with({
+          where: addWhere(this[DATA], where)
+        })
+      );
     }
     take(limit) {
-      return new SelectSingle({ ...this[DATA], limit });
+      return new SelectSingle(this[DATA].with({ limit }));
     }
     skip(offset) {
-      return new SelectSingle({ ...this[DATA], offset });
+      return new SelectSingle(this[DATA].with({ offset }));
     }
     all() {
-      return new SelectMultiple({ ...this[DATA], singleResult: false });
+      return new SelectMultiple(this[DATA].with({ singleResult: false }));
     }
     [Expr.ToExpr]() {
       return new Expr(new ExprData.Query(this[DATA]));

package/dist/define/Table.d.ts

@@ -1,5 +1,6 @@
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column';
 import { EV } from './Expr';
+import { Fields } from './Fields';
 import { Index, IndexData } from './Index';
 import { Query } from './Query';
 import { Selection } from './Selection';
@@ -38,7 +39,7 @@ export declare namespace Table {
     export const Data: typeof DATA;
     export const Meta: typeof META;
     export type Of<Row> = Table<{
-        [K in keyof Row as K extends string ? K : never]: Column<Row[K]>;
+        [K in keyof Row as K extends string ? K : never]: Fields<Row[K]>;
     }>;
     export type Select<Definition> = {
         [K in keyof Definition as Definition[K] extends Column<any> ? K : never]: Definition[K] extends Column<infer T> ? T : never;
@@ -61,6 +62,7 @@ interface Define<T> {
     new (): T;
 }
 export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
+export declare function virtualTable<Definition>(name: string): Table<Definition>;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
 export declare function table<T extends {}>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {

package/dist/define/Table.js

@@ -8,6 +8,7 @@ import { Query } from "./Query.js";
 import { Target } from "./Target.js";
 var {
   assign,
+  create,
   keys,
   entries,
   fromEntries,
@@ -28,6 +29,42 @@ var Table;
   Table2.Data = DATA;
   Table2.Meta = META;
 })(Table || (Table = {}));
+function virtualTable(name) {
+  const data = new TableData({
+    name,
+    columns: {},
+    definition: create(null),
+    meta: () => ({ indexes: {} })
+  });
+  const target = new Target.Table(data);
+  const cache = create(null);
+  function call(...args) {
+    const isConditionalRecord = args.length === 1 && !Expr.isExpr(args[0]);
+    const conditions = isConditionalRecord ? entries(args[0]).map(([key, value]) => {
+      return new Expr(
+        new ExprData.BinOp(
+          BinOpType.Equals,
+          new ExprData.Field(new ExprData.Row(target), key),
+          ExprData.create(value)
+        )
+      );
+    }) : args;
+    return new Query.TableSelect(data, conditions);
+  }
+  return new Proxy(call, {
+    get(_, column) {
+      if (column === DATA)
+        return data;
+      if (column === Expr.ToExpr)
+        return new Expr(new ExprData.Row(target));
+      if (column in cache)
+        return cache[column];
+      return (cache[column] = new Expr(
+        new ExprData.Field(new ExprData.Row(target), column)
+      )).dynamic();
+    }
+  });
+}
 function createTable(data) {
   const target = new Target.Table(data);
   const call = {
@@ -123,5 +160,6 @@ export {
   Table,
   TableData,
   createTable,
-  table
+  table,
+  virtualTable
 };

package/dist/define/Target.d.ts

@@ -3,12 +3,19 @@ import type { QueryData } from './Query';
 import type { TableData } from './Table';
 export declare enum TargetType {
     Expr = "Target.Expr",
+    CTE = "Target.CTE",
     Query = "Target.Query",
     Table = "Target.Table",
     Join = "Target.Join"
 }
-export type Target = Target.Expr | Target.Query | Target.Table | Target.Join;
+export type Target = Target.Expr | Target.CTE | Target.Query | Target.Table | Target.Join;
 export declare namespace Target {
+    class CTE {
+        name: string;
+        union: QueryData.Union;
+        type: TargetType.CTE;
+        constructor(name: string, union: QueryData.Union);
+    }
     class Expr {
         expr: ExprData;
         alias?: string | undefined;

package/dist/define/Target.js

@@ -1,6 +1,7 @@
 // src/define/Target.ts
 var TargetType = /* @__PURE__ */ ((TargetType2) => {
   TargetType2["Expr"] = "Target.Expr";
+  TargetType2["CTE"] = "Target.CTE";
   TargetType2["Query"] = "Target.Query";
   TargetType2["Table"] = "Target.Table";
   TargetType2["Join"] = "Target.Join";
@@ -8,6 +9,14 @@ var TargetType = /* @__PURE__ */ ((TargetType2) => {
 })(TargetType || {});
 var Target;
 ((Target2) => {
+  class CTE {
+    constructor(name, union) {
+      this.name = name;
+      this.union = union;
+    }
+    type = "Target.CTE" /* CTE */;
+  }
+  Target2.CTE = CTE;
   class Expr {
     constructor(expr, alias) {
       this.expr = expr;

package/dist/lib/Driver.js

@@ -109,7 +109,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];
@@ -229,7 +229,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
           );

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;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",