rado 0.0.0 → 0.1.0

package/dist/Column.d.ts

@@ -1,28 +1,33 @@
+import { Expr, ExprData } from './Expr';
 export declare const enum ColumnType {
     String = "String",
     Integer = "Integer",
     Number = "Number",
     Boolean = "Boolean",
-    Object = "Object",
-    Array = "Array"
+    Json = "Json"
 }
-export interface ColumnData {
+interface PartialColumnData {
     type: ColumnType;
     name?: string;
     nullable?: boolean;
+    defaultValue?: any;
     autoIncrement?: boolean;
     primaryKey?: boolean;
     unique?: boolean;
-    defaultValue?: any;
-    generated?: boolean;
+    references?: ExprData;
+}
+export interface ColumnData extends PartialColumnData {
+    type: ColumnType;
+    name: string;
 }
 export declare class Column<T = any> {
-    data: ColumnData;
-    constructor(data: ColumnData);
+    data: PartialColumnData;
+    constructor(data: PartialColumnData);
     name(name: string): Column<T>;
     nullable(): Column<T | null>;
     autoIncrement(): Column<T & Column.Optional>;
     primaryKey(): Column<T & Column.Optional>;
+    references(column: Expr<T>): Column<any>;
     unique(): Column<T>;
     defaultValue(value: T): Column<T & Column.Optional>;
 }
@@ -41,3 +46,4 @@ export declare const column: {
     object<T_4 extends object = object>(): Column<T_4>;
     array<T_5 = any>(): Column<T_5[]>;
 };
+export {};

package/dist/Column.js

@@ -1,11 +1,11 @@
 // src/Column.ts
+import { ExprData } from "./Expr.js";
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
   ColumnType2["Integer"] = "Integer";
   ColumnType2["Number"] = "Number";
   ColumnType2["Boolean"] = "Boolean";
-  ColumnType2["Object"] = "Object";
-  ColumnType2["Array"] = "Array";
+  ColumnType2["Json"] = "Json";
   return ColumnType2;
 })(ColumnType || {});
 var Column = class {
@@ -24,6 +24,9 @@ var Column = class {
   primaryKey() {
     return new Column({ ...this.data, primaryKey: true });
   }
+  references(column2) {
+    return new Column({ ...this.data, references: ExprData.create(column2) });
+  }
   unique() {
     return new Column({ ...this.data, unique: true });
   }
@@ -45,10 +48,10 @@ var column = {
     return new Column({ type: "Boolean" /* Boolean */ });
   },
   object() {
-    return new Column({ type: "Object" /* Object */ });
+    return new Column({ type: "Json" /* Json */ });
   },
   array() {
-    return new Column({ type: "Array" /* Array */ });
+    return new Column({ type: "Json" /* Json */ });
   }
 };
 export {

package/dist/Cursor.d.ts

@@ -1,8 +1,9 @@
 import { EV, Expr } from './Expr';
 import { OrderBy } from './OrderBy';
 import { Query } from './Query';
+import { Schema } from './Schema';
 import { Selection } from './Selection';
-import { Table, TableData } from './Table';
+import { Table } from './Table';
 import { Update as UpdateSet } from './Update';
 export declare class Cursor<T> {
     /** @internal */
@@ -39,13 +40,13 @@ export declare namespace Cursor {
         returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
     }
     class Insert<T> {
-        protected into: TableData;
-        constructor(into: TableData);
+        protected into: Schema;
+        constructor(into: Schema);
         values(...data: Array<Table.Insert<T>>): InsertValues;
     }
     class Create extends Cursor<void> {
-        protected table: TableData;
-        constructor(table: TableData);
+        protected table: Schema;
+        constructor(table: Schema);
     }
     class Batch<T = void> extends Cursor<T> {
         protected queries: Array<Query>;

package/dist/Cursor.js

@@ -2,6 +2,7 @@
 import { Expr, ExprData } from "./Expr.js";
 import { Functions } from "./Functions.js";
 import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
 var Cursor = class {
   constructor(query) {
@@ -75,7 +76,7 @@ var Cursor = class {
   Cursor2.Insert = Insert;
   class Create extends Cursor2 {
     constructor(table) {
-      super(Query.CreateTable({ table, ifNotExists: true }));
+      super(Schema.create(table));
       this.table = table;
     }
   }
@@ -97,7 +98,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "left",
           Expr.and(...on).expr
         )
@@ -109,7 +110,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "inner",
           Expr.and(...on).expr
         )
@@ -161,7 +162,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "left",
           Expr.and(...on).expr
         )
@@ -173,7 +174,7 @@ var Cursor = class {
         ...query,
         from: Target.Join(
           query.from,
-          Target.Table(that.data()),
+          Target.Table(that.schema()),
           "inner",
           Expr.and(...on).expr
         )

package/dist/Driver.d.ts

@@ -1,10 +1,15 @@
 import { Cursor } from './Cursor';
+import { Formatter } from './Formatter';
 import { Query } from './Query';
+import { SchemaInstructions } from './Schema';
+import { Statement } from './Statement';
+import { Table } from './Table';
 declare class Callable extends Function {
     constructor(fn: Function);
 }
 declare abstract class DriverBase extends Callable {
-    constructor();
+    formatter: Formatter;
+    constructor(formatter: Formatter);
     all(strings: TemplateStringsArray, ...params: Array<any>): any;
     get(strings: TemplateStringsArray, ...params: Array<any>): any;
     executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
@@ -17,7 +22,14 @@ export declare namespace Driver {
     }
     export abstract class Sync extends DriverBase {
         transactionId: number;
-        abstract execute(query: Query): any;
+        abstract rows(stmt: Statement.Compiled): Array<object>;
+        abstract values(stmt: Statement.Compiled): Array<Array<any>>;
+        abstract execute(stmt: Statement.Compiled): void;
+        abstract mutate(stmt: Statement.Compiled): {
+            rowsAffected: number;
+        };
+        abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+        migrateSchema(...tables: Array<Table<any>>): unknown;
         executeQuery<T>(query: Query<T>): T;
         all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
         get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
@@ -30,8 +42,15 @@ export declare namespace Driver {
     }
     export abstract class Async extends DriverBase {
         transactionId: number;
-        abstract execute(query: Query): Promise<any>;
         abstract isolate(): [connection: Async, release: () => Promise<void>];
+        abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
+        abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+        abstract execute(stmt: Statement.Compiled): Promise<void>;
+        abstract mutate(stmt: Statement.Compiled): Promise<{
+            rowsAffected: number;
+        }>;
+        abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+        migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
         executeQuery<T>(query: Query<T>): Promise<T>;
         all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
         get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
@@ -41,7 +60,14 @@ export declare namespace Driver {
         private sync;
         lock: Promise<void> | undefined;
         constructor(sync: Sync);
-        execute<T>(query: Query<T>): Promise<T>;
+        executeQuery<T>(query: Query<T>): Promise<T>;
+        rows(stmt: Statement.Compiled): Promise<Array<object>>;
+        values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+        execute(stmt: Statement.Compiled): Promise<void>;
+        mutate(stmt: Statement.Compiled): Promise<{
+            rowsAffected: number;
+        }>;
+        schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
         isolate(): [connection: Async, release: () => Promise<void>];
     }
     export {};

package/dist/Driver.js

@@ -1,6 +1,7 @@
 // src/Driver.ts
 import { Cursor } from "./Cursor.js";
 import { Query, QueryType } from "./Query.js";
+import { Schema } from "./Schema.js";
 var Callable = class extends Function {
   constructor(fn) {
     super();
@@ -12,13 +13,14 @@ var Callable = class extends Function {
   }
 };
 var DriverBase = class extends Callable {
-  constructor() {
+  constructor(formatter) {
     super((...args) => {
       const [input, ...rest] = args;
       if (input instanceof Cursor)
         return this.executeQuery(input.query());
       return this.executeTemplate(void 0, input, ...rest);
     });
+    this.formatter = formatter;
   }
   all(strings, ...params) {
     return this.executeTemplate("rows", strings, ...params);
@@ -36,16 +38,57 @@ var Driver;
 ((Driver2) => {
   class Sync extends DriverBase {
     transactionId = 0;
+    migrateSchema(...tables) {
+      const queries = [];
+      for (const table of Object.values(tables)) {
+        const schema = table.schema();
+        const localSchema = this.schemaInstructions(schema.name);
+        if (!localSchema) {
+          queries.push(...Schema.create(schema).queries);
+        } else {
+          const changes = Schema.upgrade(this.formatter, localSchema, schema);
+          if (changes.length)
+            queries.push(...changes);
+        }
+      }
+      return this.executeQuery(Query.Batch({ queries }));
+    }
     executeQuery(query) {
       switch (query.type) {
         case QueryType.Batch:
           let result;
           const stmts = query.queries;
-          for (const query2 of stmts)
-            result = this.execute(query2);
-          return result;
+          if (stmts.length === 0)
+            return void 0;
+          if (stmts.length === 1)
+            return this.executeQuery(stmts[0]);
+          return this.transaction((cnx) => {
+            for (const query2 of stmts)
+              result = cnx.executeQuery(query2);
+            return result;
+          });
         default:
-          return this.execute(query);
+          const stmt = this.formatter.compile(query);
+          if ("selection" in query) {
+            const res = this.values(stmt).map(
+              ([item]) => JSON.parse(item).result
+            );
+            if (query.singleResult)
+              return res[0];
+            return res;
+          } else if (query.type === QueryType.Raw) {
+            switch (query.expectedReturn) {
+              case "row":
+                return this.rows(stmt)[0];
+              case "rows":
+                return this.rows(stmt);
+              default:
+                this.execute(stmt);
+                return void 0;
+            }
+          } else {
+            return this.mutate(stmt);
+          }
       }
     }
     all(strings, ...params) {
@@ -56,17 +99,17 @@ var Driver;
     }
     transaction(run) {
       const id = `t${this.transactionId++}`;
-      this.execute(
+      this.executeQuery(
         Query.Transaction({ op: Query.TransactionOperation.Begin, id })
       );
       try {
         const res = run(this);
-        this.execute(
+        this.executeQuery(
           Query.Transaction({ op: Query.TransactionOperation.Commit, id })
         );
         return res;
       } catch (e) {
-        this.execute(
+        this.executeQuery(
           Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
         );
         throw e;
@@ -79,16 +122,57 @@ var Driver;
   Driver2.Sync = Sync;
   class Async extends DriverBase {
     transactionId = 0;
+    async migrateSchema(...tables) {
+      const queries = [];
+      for (const table of Object.values(tables)) {
+        const schema = table.schema();
+        const localSchema = await this.schemaInstructions(schema.name);
+        if (!localSchema) {
+          queries.push(...Schema.create(schema).queries);
+        } else {
+          const changes = Schema.upgrade(this.formatter, localSchema, schema);
+          if (changes.length)
+            queries.push(...changes);
+        }
+      }
+      return this.executeQuery(Query.Batch({ queries }));
+    }
     async executeQuery(query) {
       switch (query.type) {
         case QueryType.Batch:
           let result;
           const stmts = query.queries;
-          for (const query2 of stmts)
-            result = await this.execute(query2);
-          return result;
+          if (stmts.length === 0)
+            return void 0;
+          if (stmts.length === 1)
+            return this.executeQuery(stmts[0]);
+          return this.transaction(async (cnx) => {
+            for (const query2 of stmts)
+              result = await cnx.executeQuery(query2);
+            return result;
+          });
         default:
-          return this.execute(query);
+          const stmt = this.formatter.compile(query);
+          if ("selection" in query) {
+            const res = (await this.values(stmt)).map(
+              ([item]) => JSON.parse(item).result
+            );
+            if (query.singleResult)
+              return res[0];
+            return res;
+          } else if (query.type === QueryType.Raw) {
+            switch (query.expectedReturn) {
+              case "row":
+                return (await this.rows(stmt))[0];
+              case "rows":
+                return await this.rows(stmt);
+              default:
+                await this.execute(stmt);
+                return void 0;
+            }
+          } else {
+            return await this.mutate(stmt);
+          }
       }
     }
     all(strings, ...params) {
@@ -100,17 +184,17 @@ var Driver;
     async transaction(run) {
       const id = `t${this.transactionId++}`;
       const [connection, release] = this.isolate();
-      await connection.execute(
+      await connection.executeQuery(
         Query.Transaction({ op: Query.TransactionOperation.Begin, id })
       );
       try {
         const res = await run(connection);
-        await connection.execute(
+        await connection.executeQuery(
           Query.Transaction({ op: Query.TransactionOperation.Commit, id })
         );
         return res;
       } catch (e) {
-        await connection.execute(
+        await connection.executeQuery(
           Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
         );
         throw e;
@@ -122,13 +206,28 @@ var Driver;
   Driver2.Async = Async;
   class SyncWrapper extends Async {
     constructor(sync) {
-      super();
+      super(sync.formatter);
       this.sync = sync;
     }
     lock;
-    async execute(query) {
+    async executeQuery(query) {
       await this.lock;
-      return this.sync.execute(query);
+      return super.executeQuery(query);
+    }
+    async rows(stmt) {
+      return this.sync.rows(stmt);
+    }
+    async values(stmt) {
+      return this.sync.values(stmt);
+    }
+    async execute(stmt) {
+      return this.sync.execute(stmt);
+    }
+    async mutate(stmt) {
+      return this.sync.mutate(stmt);
+    }
+    async schemaInstructions(tableName) {
+      return this.sync.schemaInstructions(tableName);
     }
     isolate() {
       const connection = new SyncWrapper(this.sync);

package/dist/Formatter.d.ts

@@ -7,27 +7,32 @@ import { Statement } from './Statement';
 import { Target } from './Target';
 export interface FormatContext {
     nameResult?: string;
+    skipTableName?: boolean;
     formatAsJson?: boolean;
     formatSubject?: (subject: Statement) => Statement;
 }
 export declare abstract class Formatter implements Sanitizer {
     constructor();
     abstract escapeValue(value: any): string;
-    abstract escapeIdent(ident: string): string;
+    abstract escapeIdentifier(ident: string): string;
     abstract formatSqlAccess(on: Statement, field: string): Statement;
     abstract formatJsonAccess(on: Statement, field: string): Statement;
     formatAccess(on: Statement, field: string, formatAsJson?: boolean): Statement;
-    compile<T>(query: Query<T>, formatInline?: boolean): [string, any[]];
+    compile<T>(query: Query<T>, formatInline?: boolean): Statement.Compiled;
     format<T>(query: Query<T>, ctx?: FormatContext): Statement;
     formatSelect(query: Query.Select, ctx: FormatContext): Statement;
     formatInsert(query: Query.Insert, ctx: FormatContext): Statement;
     formatUpdate(query: Query.Update, ctx: FormatContext): Statement;
     formatDelete(query: Query.Delete, ctx: FormatContext): Statement;
     formatCreateTable(query: Query.CreateTable, ctx: FormatContext): Statement;
+    formatCreateIndex(query: Query.CreateIndex, ctx?: FormatContext): Statement;
+    formatDropIndex(query: Query.DropIndex, ctx: FormatContext): Statement;
+    formatAlterTable(query: Query.AlterTable, ctx: FormatContext): Statement;
     formatTransaction({ op, id }: Query.Transaction, ctx: FormatContext): Statement;
     formatBatch(queries: Query[], ctx: FormatContext): Statement;
     formatRaw({ strings, params }: Query.Raw, ctx: FormatContext): Statement;
     formatColumn(column: ColumnData): Statement;
+    formatContraintReference(reference: ExprData): Statement;
     formatType(type: ColumnType): Statement;
     formatInsertRow(columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
     formatColumnValue(column: ColumnData, columnValue: any): Statement;
@@ -44,6 +49,7 @@ export declare abstract class Formatter implements Sanitizer {
     retrieveField(expr: ExprData, field: string): ExprData | undefined;
     formatField(expr: ExprData, field: string, ctx: FormatContext): Statement;
     formatString(input: string): Statement;
+    formatInlineValue(rawValue: any): Statement;
     formatValue(rawValue: any, formatAsJson?: boolean): Statement;
     formatExpr(expr: ExprData, ctx: FormatContext): Statement;
 }

package/dist/Formatter.js

@@ -65,6 +65,12 @@ var Formatter = class {
         return this.formatDelete(query, ctx);
       case QueryType.CreateTable:
         return this.formatCreateTable(query, ctx);
+      case QueryType.CreateIndex:
+        return this.formatCreateIndex(query, ctx);
+      case QueryType.DropIndex:
+        return this.formatDropIndex(query, ctx);
+      case QueryType.AlterTable:
+        return this.formatAlterTable(query, ctx);
       case QueryType.Transaction:
         return this.formatTransaction(query, ctx);
       case QueryType.Batch:
@@ -114,6 +120,29 @@ var Formatter = class {
       })
     );
   }
+  formatCreateIndex(query, ctx = {}) {
+    return raw("create index").addIf(query.ifNotExists, "if not exists").addIdentifier(query.index.name).add("on").addIdentifier(query.table.name).parenthesis(
+      separated(
+        query.index.on.map(
+          (expr) => this.formatExprValue(expr, { ...ctx, skipTableName: true })
+        )
+      )
+    ).add(this.formatWhere(query.where, ctx));
+  }
+  formatDropIndex(query, ctx) {
+    return raw("drop index").addIf(query.ifExists, "if exists").addIdentifier(query.index.name);
+  }
+  formatAlterTable(query, ctx) {
+    let stmt = raw("alter table").addIdentifier(query.table.name);
+    if (query.addColumn) {
+      stmt = stmt.add("add column").add(this.formatColumn(query.addColumn));
+    } else if (query.dropColumn) {
+      stmt = stmt.add("drop column").addIdentifier(query.dropColumn);
+    } else if (query.alterColumn) {
+      throw new Error(`Not available in this formatter: alter column`);
+    }
+    return stmt;
+  }
   formatTransaction({ op, id }, ctx) {
     switch (op) {
       case Query.TransactionOperation.Begin:
@@ -131,23 +160,32 @@ var Formatter = class {
     );
   }
   formatRaw({ strings, params }, ctx) {
-    return Statement.ofTemplate(strings, params);
+    return Statement.tag(strings, ...params);
   }
   formatColumn(column) {
     return identifier(column.name).add(this.formatType(column.type)).addIf(column.unique, "unique").addIf(column.autoIncrement, "autoincrement").addIf(column.primaryKey, "primary key").addIf(!column.nullable, "not null").addIf(
       column.defaultValue !== void 0,
-      raw("default").value(column.defaultValue)
-    );
+      raw("default").add(this.formatInlineValue(column.defaultValue))
+    ).addIf(column.references, () => {
+      return this.formatContraintReference(column.references);
+    });
+  }
+  formatContraintReference(reference) {
+    if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
+      throw new Error("not supported");
+    const from = reference.expr.target;
+    return raw("references").addIdentifier(Target.source(from).name).parenthesis(identifier(reference.field));
   }
   formatType(type) {
     switch (type) {
       case ColumnType.String:
-      case ColumnType.Object:
-      case ColumnType.Array:
         return raw("text");
+      case ColumnType.Json:
+        return raw("json");
       case ColumnType.Number:
-      case ColumnType.Boolean:
         return raw("numeric");
+      case ColumnType.Boolean:
+        return raw("boolean");
       case ColumnType.Integer:
         return raw("integer");
     }
@@ -184,14 +222,10 @@ var Formatter = class {
         if (typeof columnValue !== "boolean")
           throw new TypeError(`Expected boolean for column ${column.name}`);
         return value(columnValue);
-      case ColumnType.Object:
+      case ColumnType.Json:
         if (typeof columnValue !== "object")
           throw new TypeError(`Expected object for column ${column.name}`);
         return value(JSON.stringify(columnValue));
-      case ColumnType.Array:
-        if (!Array.isArray(columnValue))
-          throw new TypeError(`Expected array for column ${column.name}`);
-        return value(JSON.stringify(columnValue));
     }
   }
   formatTarget(target, ctx) {
@@ -283,13 +317,10 @@ var Formatter = class {
       case ExprType.Row:
         switch (expr.target.type) {
           case TargetType.Table:
-            const selection = identifier(
-              expr.target.table.alias || expr.target.table.name
-            ).raw(".").identifier(field);
+            const selection = ctx.skipTableName ? identifier(field) : identifier(expr.target.table.alias || expr.target.table.name).raw(".").identifier(field);
             const column = expr.target.table.columns[field];
             switch (column?.type) {
-              case ColumnType.Array:
-              case ColumnType.Object:
+              case ColumnType.Json:
                 return call("json", selection);
               default:
                 return selection;
@@ -306,6 +337,18 @@ var Formatter = class {
   formatString(input) {
     return raw(this.escapeValue(String(input)));
   }
+  formatInlineValue(rawValue) {
+    switch (true) {
+      case (rawValue === null || rawValue === void 0):
+        return raw("null");
+      case typeof rawValue === "boolean":
+        return rawValue ? raw("true") : raw("false");
+      case (typeof rawValue === "string" || typeof rawValue === "number"):
+        return this.formatString(rawValue);
+      default:
+        return this.formatString(JSON.stringify(rawValue));
+    }
+  }
   formatValue(rawValue, formatAsJson) {
     switch (true) {
       case (rawValue === null || rawValue === void 0):
@@ -407,7 +450,7 @@ var Formatter = class {
         return call(
           "json_object",
           ...Object.entries(expr.fields).map(([key, value2]) => {
-            return this.formatString(key).raw(",").newline().concat(this.formatExpr(value2, { ...ctx, formatAsJson: true }));
+            return this.formatString(key).raw(", ").concat(this.formatExpr(value2, { ...ctx, formatAsJson: true }));
           })
         );
       case ExprType.Filter: {

package/dist/Ops.js

@@ -2,38 +2,37 @@
 import { Cursor } from "./Cursor.js";
 import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
 import { Target } from "./Target.js";
 function selectAll(table) {
   return new Cursor.SelectMultiple(
     Query.Select({
-      from: Target.Table(table.data()),
-      selection: ExprData.Row(Target.Table(table.data()))
+      from: Target.Table(table.schema()),
+      selection: ExprData.Row(Target.Table(table.schema()))
     })
   );
 }
 function selectFirst(table) {
   return new Cursor.SelectSingle(
     Query.Select({
-      from: Target.Table(table.data()),
-      selection: ExprData.Row(Target.Table(table.data())),
+      from: Target.Table(table.schema()),
+      selection: ExprData.Row(Target.Table(table.schema())),
       singleResult: true
     })
   );
 }
 function update(table) {
-  return new Cursor.Update(Query.Update({ table: table.data() }));
+  return new Cursor.Update(Query.Update({ table: table.schema() }));
 }
 function insertInto(table) {
-  return new Cursor.Insert(table.data());
+  return new Cursor.Insert(table.schema());
 }
 function deleteFrom(table) {
-  return new Cursor.Delete(Query.Delete({ table: table.data() }));
+  return new Cursor.Delete(Query.Delete({ table: table.schema() }));
 }
 function create(...tables) {
   return new Cursor.Batch(
-    tables.map(
-      (table) => Query.CreateTable({ table: table.data(), ifNotExists: true })
-    )
+    tables.flatMap((table) => Schema.create(table.schema()).queries)
   );
 }
 export {