rado 0.2.25 → 0.2.27

package/dist/define/Expr.js

@@ -1,4 +1,5 @@
 // src/define/Expr.ts
+import { randomAlias } from "../util/Alias.js";
 import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";
@@ -336,7 +337,7 @@ var Expr = class {
     return Expr.create(value).isIn(this);
   }
   filter(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
+    const alias = randomAlias();
     const target = new Target.Expr(this[DATA], alias);
     return new Expr(
       new ExprData.Filter(
@@ -346,7 +347,7 @@ var Expr = class {
     );
   }
   map(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
+    const alias = randomAlias();
     const target = new Target.Expr(this[DATA], alias);
     return new Expr(
       new ExprData.Map(

package/dist/define/Ops.d.ts

@@ -4,7 +4,10 @@ import { Batch } from './query/Batch';
 import { Delete } from './query/Delete';
 import { Insert } from './query/Insert';
 import { SelectMultiple } from './query/Select';
+import { RecursiveUnion } from './query/Union';
 import { Update } from './query/Update';
+export declare function withRecursive<Row>(initialSelect: SelectMultiple<Row>): RecursiveUnion<Row>;
+export declare function alias<T extends Table<{}>>(table: T): Record<string, T>;
 export declare function select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
 export declare function from<Row>(source: Table<Row> | SelectMultiple<Row>): SelectMultiple<Row>;
 export declare function update<Row>(table: Table<Row>): Update<Row>;

package/dist/define/Ops.js

@@ -2,13 +2,24 @@
 import { ExprData } from "./Expr.js";
 import { Query, QueryData } from "./Query.js";
 import { Schema } from "./Schema.js";
-import { Table } from "./Table.js";
+import { Table, createTable } from "./Table.js";
 import { Target } from "./Target.js";
 import { Batch } from "./query/Batch.js";
 import { Delete } from "./query/Delete.js";
 import { Insert } from "./query/Insert.js";
 import { SelectMultiple } from "./query/Select.js";
+import { RecursiveUnion } from "./query/Union.js";
 import { Update } from "./query/Update.js";
+function withRecursive(initialSelect) {
+  return new RecursiveUnion(initialSelect[Query.Data]);
+}
+function alias(table) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_, alias2) {
+      return createTable({ ...table[Table.Data], alias: alias2 });
+    }
+  });
+}
 function select(selection) {
   return new SelectMultiple(
     new QueryData.Select({
@@ -40,10 +51,12 @@ function create(...tables) {
   );
 }
 export {
+  alias,
   create,
   deleteFrom,
   from,
   insertInto,
   select,
-  update
+  update,
+  withRecursive
 };

package/dist/define/Query.d.ts

@@ -49,7 +49,7 @@ export declare namespace QueryData {
         type: QueryType.Union;
         a: Select | Union;
         operator: UnionOperation;
-        b: Select | Union;
+        b: Select | Union | (() => Select | Union);
     }
     export class Select extends Data<Select> {
         type: QueryType.Select;

package/dist/define/Table.d.ts

@@ -1,3 +1,4 @@
+import { ClearFunctionProto } from '../util/Callable';
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column';
 import { EV, Expr } from './Expr';
 import type { Fields } from './Fields';
@@ -18,7 +19,7 @@ export declare class TableData {
     };
     constructor(data: TableData);
 }
-export interface TableInstance<Definition> {
+export interface TableInstance<Definition> extends ClearFunctionProto {
     (conditions: {
         [K in keyof Definition]?: Definition[K] extends Expr<infer V> ? EV<V> : never;
     }): TableSelect<Definition>;
@@ -27,19 +28,13 @@ export interface TableInstance<Definition> {
 export declare class TableInstance<Definition> {
     [Selection.TableType](): Table.Select<Definition>;
     get [DATA](): TableData;
-    get name(): unknown;
-    get length(): unknown;
-    get call(): unknown;
-    get apply(): unknown;
-    get bind(): unknown;
-    get prototype(): unknown;
 }
 export type Table<Definition> = Definition & TableInstance<Definition>;
 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]: Fields<Row[K]>;
+        [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & 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;
@@ -62,7 +57,6 @@ 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,7 +8,6 @@ import { Target } from "./Target.js";
 import { TableSelect } from "./query/TableSelect.js";
 var {
   assign,
-  create,
   keys,
   entries,
   fromEntries,
@@ -29,42 +28,6 @@ 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 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 = {
@@ -160,6 +123,5 @@ export {
   Table,
   TableData,
   createTable,
-  table,
-  virtualTable
+  table
 };

package/dist/define/VirtualTable.d.ts

@@ -0,0 +1,33 @@
+import { ClearFunctionProto } from '../util/Callable';
+import { Column } from './Column';
+import { EV, Expr } from './Expr';
+import { Fields } from './Fields';
+import { Selection } from './Selection';
+import { Table } from './Table';
+import { Target } from './Target';
+import { SelectMultiple } from './query/Select';
+declare const DATA: unique symbol;
+export interface VirtualTableInstance<Definition> extends ClearFunctionProto {
+    (conditions: {
+        [K in keyof Definition]?: Definition[K] extends Expr<infer V> ? EV<V> : never;
+    }): SelectMultiple<Table.Select<Definition>>;
+    (...conditions: Array<EV<boolean>>): SelectMultiple<Table.Select<Definition>>;
+}
+export declare class VirtualTableInstance<Definition> {
+    [Selection.TableType](): Table.Select<Definition>;
+    get [DATA](): VirtualTableData;
+}
+export interface VirtualTableData {
+    name: string;
+    target: Target;
+    select: (conditions: Array<EV<boolean>>) => SelectMultiple<any>;
+}
+export type VirtualTable<Definition> = Definition & VirtualTableInstance<Definition>;
+export declare namespace VirtualTable {
+    const Data: typeof DATA;
+    type Of<Row> = VirtualTable<{
+        [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & Fields<Row[K]>;
+    }>;
+}
+export declare function createVirtualTable<Definition>(data: VirtualTableData): VirtualTable<Definition>;
+export {};

package/dist/define/VirtualTable.js

@@ -0,0 +1,41 @@
+// src/define/VirtualTable.ts
+import { BinOpType, Expr, ExprData } from "./Expr.js";
+var { create, entries } = Object;
+var DATA = Symbol("VirtualTable.Data");
+var VirtualTable;
+((VirtualTable2) => {
+  VirtualTable2.Data = DATA;
+})(VirtualTable || (VirtualTable = {}));
+function createVirtualTable(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(data.target), key),
+          ExprData.create(value)
+        )
+      );
+    }) : args;
+    return data.select(conditions);
+  }
+  return new Proxy(call, {
+    get(_, column) {
+      if (column === DATA)
+        return data;
+      if (column === Expr.ToExpr)
+        return new Expr(new ExprData.Row(data.target));
+      if (column in cache)
+        return cache[column];
+      return (cache[column] = new Expr(
+        new ExprData.Field(new ExprData.Row(data.target), column)
+      )).dynamic();
+    }
+  });
+}
+export {
+  VirtualTable,
+  createVirtualTable
+};

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

@@ -3,14 +3,14 @@ import { OrderBy } from '../OrderBy';
 import { Query, QueryData } from '../Query';
 import { Selection } from '../Selection';
 import { Table } from '../Table';
-import { TableSelect } from './TableSelect';
+import { VirtualTable } from '../VirtualTable';
 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>;
+    from(table: Table<any> | VirtualTable<any>): SelectMultiple<Row>;
+    leftJoin<C>(that: Table<C> | SelectMultiple<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
+    innerJoin<C>(that: Table<C> | SelectMultiple<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>;
@@ -20,16 +20,14 @@ export declare class SelectMultiple<Row> extends Union<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>;
+    leftJoin<C>(that: Table<C> | SelectMultiple<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
+    innerJoin<C>(that: Table<C> | SelectMultiple<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>;

package/dist/define/query/Select.js

@@ -1,10 +1,10 @@
 // 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 { Query } from "../Query.js";
 import { Table } from "../Table.js";
 import { Target } from "../Target.js";
+import { VirtualTable } from "../VirtualTable.js";
 import { Union } from "./Union.js";
 function joinTarget(joinType, query, to, on) {
   const toQuery = Query.isQuery(to) ? to[Query.Data] : void 0;
@@ -29,8 +29,9 @@ var SelectMultiple = class extends Union {
     super(query);
   }
   from(table) {
+    const virtual = table[VirtualTable.Data];
     return new SelectMultiple(
-      this[Query.Data].with({ from: new Target.Table(table) })
+      this[Query.Data].with({ from: virtual?.target || new Target.Table(table) })
     );
   }
   leftJoin(that, ...on) {
@@ -100,24 +101,6 @@ var SelectMultiple = class extends Union {
   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]));
   }

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

@@ -1,5 +1,12 @@
 import { Query, QueryData } from '../Query';
+import { VirtualTable } from '../VirtualTable';
 import { SelectMultiple } from './Select';
+export declare class RecursiveUnion<Row> {
+    initialSelect: QueryData.Select;
+    constructor(initialSelect: QueryData.Select);
+    union(create: () => SelectMultiple<Row> | Union<Row>): VirtualTable.Of<Row>;
+    unionAll(create: () => SelectMultiple<Row> | Union<Row>): VirtualTable.Of<Row>;
+}
 export declare class Union<Row> extends Query<Array<Row>> {
     [Query.Data]: QueryData.Union | QueryData.Select;
     constructor(query: QueryData.Union | QueryData.Select);

package/dist/define/query/Union.js

@@ -1,5 +1,75 @@
 // src/define/query/Union.ts
+import { randomAlias } from "../../util/Alias.js";
+import { Expr, ExprData, ExprType } from "../Expr.js";
 import { Query, QueryData } from "../Query.js";
+import { Target, TargetType } from "../Target.js";
+import { createVirtualTable } from "../VirtualTable.js";
+import { SelectMultiple } from "./Select.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) {
+  const name = randomAlias();
+  const cols = columnsOf(initial.selection);
+  const union = new QueryData.Union({
+    a: initial,
+    operator,
+    b: () => createUnion()[Query.Data]
+  });
+  const target = new Target.CTE(name, union);
+  const row = new ExprData.Row(target);
+  const selection = new ExprData.Record(
+    fromEntries(cols.map((col) => [col, new ExprData.Field(row, col)]))
+  );
+  const select = (conditions) => {
+    const where = Expr.and(...conditions)[Expr.Data];
+    return new SelectMultiple(
+      new QueryData.Select({
+        selection,
+        from: target,
+        where
+      })
+    );
+  };
+  const cte = createVirtualTable({
+    name,
+    target,
+    select
+  });
+  return cte;
+}
+var RecursiveUnion = class {
+  constructor(initialSelect) {
+    this.initialSelect = initialSelect;
+  }
+  union(create2) {
+    return makeRecursiveUnion(
+      this.initialSelect,
+      create2,
+      QueryData.UnionOperation.Union
+    );
+  }
+  unionAll(create2) {
+    return makeRecursiveUnion(
+      this.initialSelect,
+      create2,
+      QueryData.UnionOperation.UnionAll
+    );
+  }
+};
 var Union = class extends Query {
   constructor(query) {
     super(query);
@@ -42,5 +112,6 @@ var Union = class extends Query {
   }
 };
 export {
+  RecursiveUnion,
   Union
 };

package/dist/lib/Formatter.d.ts

@@ -23,6 +23,7 @@ export interface FormatContext {
     formatAsIn?: boolean;
     topLevel?: boolean;
     selectAsColumns?: boolean;
+    formattingCte?: string;
 }
 type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
 export interface CompileOptions extends Partial<FormatContext>, StatementOptions {
@@ -45,6 +46,7 @@ export declare abstract class Formatter implements Sanitizer {
         formatAsIn?: boolean | undefined;
         topLevel?: boolean | undefined;
         selectAsColumns?: boolean | undefined;
+        formattingCte?: string | undefined;
         skipNewlines?: boolean | undefined;
     };
     format(ctx: FormatContext, query: QueryData): Statement;
@@ -62,7 +64,7 @@ export declare abstract class Formatter implements Sanitizer {
     formatBatch(ctx: FormatContext, { queries }: QueryData.Batch): Statement;
     formatRaw(ctx: FormatContext, { strings, params }: QueryData.Raw): Statement;
     formatColumn(ctx: FormatContext, column: ColumnData): Statement;
-    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
+    formatConstraintReference(ctx: FormatContext, reference: ExprData): Statement;
     formatType(ctx: FormatContext, type: ColumnType): Statement;
     formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
     formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;

package/dist/lib/Formatter.js

@@ -89,12 +89,19 @@ var Formatter = class {
     const { stmt } = ctx;
     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();
+        if (ctx.formattingCte !== query.from.name) {
+          stmt.add("WITH RECURSIVE").addIdentifier(query.from.name).add("AS").space().openParenthesis();
+          this.formatUnion(
+            {
+              ...ctx,
+              topLevel: false,
+              selectAsColumns: true,
+              formattingCte: query.from.name
+            },
+            query.from.union
+          );
+          stmt.closeParenthesis().space();
+        }
       default:
         stmt.raw("SELECT").space();
         this.formatSelection(
@@ -118,7 +125,7 @@ var Formatter = class {
     const { stmt } = ctx;
     this.format(ctx, a);
     stmt.add(unions[operator]).space();
-    this.format(ctx, b);
+    this.format(ctx, typeof b === "function" ? b() : b);
     return stmt;
   }
   formatInsert(ctx, query) {
@@ -306,10 +313,10 @@ var Formatter = class {
       }
     }
     if (column.references)
-      this.formatContraintReference(ctx, column.references());
+      this.formatConstraintReference(ctx, column.references());
     return stmt;
   }
-  formatContraintReference(ctx, reference) {
+  formatConstraintReference(ctx, reference) {
     const { stmt } = ctx;
     if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
       throw new Error("not supported");
@@ -602,6 +609,8 @@ var Formatter = class {
     switch (from.type) {
       case ExprType.Row:
         switch (from.target.type) {
+          case TargetType.CTE:
+            return stmt.identifier(from.target.name).raw(".").identifier(field);
           case TargetType.Table:
             const column = from.target.table.columns[field];
             const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
@@ -685,6 +694,16 @@ var Formatter = class {
           throw new Error(`Cannot select empty target`);
         if (ctx.tableAsExpr)
           return stmt.identifier(table.alias || table.name);
+        if (ctx.selectAsColumns) {
+          const inner = { ...ctx, selectAsColumns: false };
+          for (const [key, column] of stmt.separate(
+            Object.entries(table.columns)
+          )) {
+            this.formatFieldOf(inner, expr, column.name);
+            stmt.add("AS").addIdentifier(key);
+          }
+          return stmt;
+        }
         stmt.identifier("json_object");
         for (const [key, column] of stmt.call(Object.entries(table.columns))) {
           this.formatString(ctx, key).raw(", ");

package/dist/util/Alias.d.ts

@@ -0,0 +1 @@
+export declare function randomAlias(): string;

package/dist/util/Alias.js

@@ -0,0 +1,7 @@
+// src/util/Alias.ts
+function randomAlias() {
+  return `__${Math.random().toString(36).slice(2, 9)}`;
+}
+export {
+  randomAlias
+};

package/dist/util/Callable.d.ts

@@ -1,3 +1,11 @@
 export declare class Callable {
     constructor(fn: Function);
 }
+export declare class ClearFunctionProto {
+    get name(): unknown;
+    get length(): unknown;
+    get call(): unknown;
+    get apply(): unknown;
+    get bind(): unknown;
+    get prototype(): unknown;
+}

package/package.json

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

package/dist/define/CTE.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,51 +0,0 @@
-// 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
-};