rado 0.4.4 → 0.4.6

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

@@ -0,0 +1,39 @@
+import { EV, Expr } from '../Expr.js';
+import { OrderBy } from '../OrderBy.js';
+import { Query, QueryData } from '../Query.js';
+import { Selection } from '../Selection.js';
+import { Table } from '../Table.js';
+import { VirtualTable } from '../VirtualTable.js';
+import { Union } from './Union.js';
+export declare class Select<Row> extends Union<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any> | VirtualTable<any>): Select<Row>;
+    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
+    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
+    select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;
+    count(): SelectFirst<number>;
+    orderBy(...orderBy: Array<Expr<any> | OrderBy>): Select<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): Select<Row>;
+    maybeFirst(): SelectFirst<Row | null>;
+    first(): SelectFirst<Row>;
+    where(...where: Array<EV<boolean>>): Select<Row>;
+    take(limit: number | undefined): Select<Row>;
+    skip(offset: number | undefined): Select<Row>;
+    [Expr.ToExpr](): Expr<Row>;
+}
+export declare class SelectFirst<Row> extends Query<Row> {
+    [Query.Data]: QueryData.Select;
+    constructor(query: QueryData.Select);
+    from(table: Table<any>): Select<Row>;
+    leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
+    innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): SelectFirst<Row>;
+    select<X extends Selection>(selection: X): SelectFirst<Selection.Infer<X>>;
+    orderBy(...orderBy: Array<OrderBy>): SelectFirst<Row>;
+    groupBy(...groupBy: Array<Expr<any>>): SelectFirst<Row>;
+    where(...where: Array<EV<boolean>>): SelectFirst<Row>;
+    take(limit: number | undefined): SelectFirst<Row>;
+    skip(offset: number | undefined): SelectFirst<Row>;
+    all(): Select<Row>;
+    [Expr.ToExpr](): Expr<Row>;
+}

package/dist/define/query/Select.js

@@ -0,0 +1,170 @@
+import { Expr, ExprData } from "../Expr.js";
+import { Functions } from "../Functions.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;
+  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]
+  );
+}
+class Select extends Union {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    const virtual = table[VirtualTable.Data];
+    return new Select(
+      this[Query.Data].with({ from: virtual?.target || new Target.Table(table) })
+    );
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new Select(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new Select(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new Select(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  count() {
+    return new SelectFirst(
+      this[Query.Data].with({
+        selection: Functions.count()[Expr.Data],
+        singleResult: true
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new Select(
+      this[Query.Data].with({
+        orderBy: orderBy.map((e) => {
+          return Expr.isExpr(e) ? e.asc() : e;
+        })
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new Select(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  maybeFirst() {
+    return new SelectFirst(this[Query.Data].with({ singleResult: true }));
+  }
+  first() {
+    return new SelectFirst(
+      this[Query.Data].with({
+        singleResult: true,
+        validate: true
+      })
+    );
+  }
+  where(...where) {
+    return new Select(this.addWhere(where));
+  }
+  take(limit) {
+    return new Select(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new Select(this[Query.Data].with({ offset }));
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+}
+class SelectFirst extends Query {
+  constructor(query) {
+    super(query);
+  }
+  from(table) {
+    return new Select(this[Query.Data].with({ from: new Target.Table(table) }));
+  }
+  leftJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectFirst(
+      this[Query.Data].with({
+        from: joinTarget("left", query, that, on)
+      })
+    );
+  }
+  innerJoin(that, ...on) {
+    const query = this[Query.Data];
+    return new SelectFirst(
+      this[Query.Data].with({
+        from: joinTarget("inner", query, that, on)
+      })
+    );
+  }
+  select(selection) {
+    return new SelectFirst(
+      this[Query.Data].with({
+        selection: ExprData.create(selection)
+      })
+    );
+  }
+  orderBy(...orderBy) {
+    return new SelectFirst(
+      this[Query.Data].with({
+        orderBy
+      })
+    );
+  }
+  groupBy(...groupBy) {
+    return new SelectFirst(
+      this[Query.Data].with({
+        groupBy: groupBy.map(ExprData.create)
+      })
+    );
+  }
+  where(...where) {
+    return new SelectFirst(this.addWhere(where));
+  }
+  take(limit) {
+    return new SelectFirst(this[Query.Data].with({ limit }));
+  }
+  skip(offset) {
+    return new SelectFirst(this[Query.Data].with({ offset }));
+  }
+  all() {
+    return new Select(this[Query.Data].with({ singleResult: false }));
+  }
+  [Expr.ToExpr]() {
+    return new Expr(new ExprData.Query(this[Query.Data]));
+  }
+}
+export {
+  Select,
+  SelectFirst
+};

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

@@ -0,0 +1,28 @@
+import { EV, Expr } from '../Expr.js';
+import { Query, QueryData } from '../Query.js';
+import { Table, TableData } from '../Table.js';
+import { CreateTable } from './CreateTable.js';
+import { Delete } from './Delete.js';
+import { Insert, InsertOne } from './Insert.js';
+import { Select } from './Select.js';
+import { Update } from './Update.js';
+export declare class TableSelect<Definition> extends Select<Table.Select<Definition>> {
+    protected table: TableData;
+    [Query.Data]: QueryData.Select;
+    constructor(table: TableData, conditions?: Array<EV<boolean>>);
+    as(alias: string): Table<Definition>;
+    create(): CreateTable;
+    insert(query: Select<Table.Insert<Definition>>): Insert;
+    insert(rows: Array<Table.Insert<Definition>>): Insert;
+    insert(row: Table.Insert<Definition>): InsertOne<Table.Select<Definition>>;
+    insertSelect(query: Select<Table.Insert<Definition>>): Insert<{
+        rowsAffected: number;
+    }>;
+    insertOne(record: Table.Insert<Definition>): InsertOne<{ [K in keyof Definition as Definition[K] extends import("../Column.js").Column<any> ? K : never]: Definition[K] extends import("../Column.js").Column<infer T> ? T : never; }>;
+    insertAll(data: Array<Table.Insert<Definition>>): Insert<{
+        rowsAffected: number;
+    }>;
+    set(data: Table.Update<Definition>): Update<Definition>;
+    delete(): Delete;
+    get(name: string): Expr<any>;
+}

package/dist/define/query/TableSelect.js

@@ -0,0 +1,79 @@
+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, InsertInto, InsertOne } from "./Insert.js";
+import { Select } from "./Select.js";
+import { Update } from "./Update.js";
+class TableSelect extends Select {
+  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);
+  }
+  insert(input) {
+    if (input instanceof Select) {
+      return this.insertSelect(input);
+    } else if (Array.isArray(input)) {
+      return this.insertAll(input);
+    } else {
+      return this.insertOne(input);
+    }
+  }
+  insertSelect(query) {
+    return new Insert(
+      new QueryData.Insert({ into: this.table, select: query[Query.Data] })
+    );
+  }
+  insertOne(record) {
+    return new InsertOne(
+      new QueryData.Insert({
+        into: this.table,
+        data: [record],
+        selection: new ExprData.Row(new Target.Table(this.table)),
+        singleResult: true
+      })
+    );
+  }
+  insertAll(data) {
+    return new InsertInto(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,17 @@
+import { Query, QueryData } from '../Query.js';
+import { VirtualTable } from '../VirtualTable.js';
+import { Select } from './Select.js';
+export declare class RecursiveUnion<Row> {
+    initialSelect: QueryData.Select;
+    constructor(initialSelect: QueryData.Select);
+    union(create: () => Select<Row> | Union<Row>): VirtualTable.Of<Row>;
+    unionAll(create: () => Select<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);
+    union(query: Select<Row> | Union<Row>): Union<Row>;
+    unionAll(query: Select<Row> | Union<Row>): Union<Row>;
+    except(query: Select<Row> | Union<Row>): Union<Row>;
+    intersect(query: Select<Row> | Union<Row>): Union<Row>;
+}

package/dist/define/query/Union.js

@@ -0,0 +1,116 @@
+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 { Select } from "./Select.js";
+const { 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 Select(
+      new QueryData.Select({
+        selection,
+        from: target,
+        where
+      })
+    );
+  };
+  const cte = createVirtualTable({
+    name,
+    target,
+    select
+  });
+  return cte;
+}
+class RecursiveUnion {
+  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
+    );
+  }
+}
+class Union 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 {
+  RecursiveUnion,
+  Union
+};

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

@@ -0,0 +1,12 @@
+import { EV } from '../Expr.js';
+import { Query, QueryData } from '../Query.js';
+import { Table } from '../Table.js';
+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,18 @@
+import { Query } from "../Query.js";
+class Update 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/deno/driver/better-sqlite3.js

@@ -0,0 +1,57 @@
+// src/driver/better-sqlite3.ts
+import { Driver } from "../lib/Driver.ts";
+import { SqlError } from "../lib/SqlError.ts";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.ts";
+import { SqliteSchema } from "../sqlite/SqliteSchema.ts";
+var PreparedStatement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  iterate(params = []) {
+    return this.stmt.iterate(...params);
+  }
+  all(params = []) {
+    return this.stmt.all(...params);
+  }
+  run(params = []) {
+    return { rowsAffected: this.stmt.run(...params).changes };
+  }
+  get(params = []) {
+    return this.stmt.get(...params);
+  }
+  execute(params = []) {
+    this.stmt.run(...params);
+  }
+};
+var BetterSqlite3Driver = 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;
+  prepareStatement(stmt) {
+    try {
+      return new PreparedStatement(this.db.prepare(stmt.sql));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  export() {
+    return this.db.serialize();
+  }
+};
+function connect(db) {
+  return new BetterSqlite3Driver(db);
+}
+export {
+  BetterSqlite3Driver,
+  connect
+};

package/dist/deno/driver/bun-sqlite.js

@@ -0,0 +1,69 @@
+// src/driver/bun-sqlite.ts
+import { Cursor } from "../define/Cursor.ts";
+import { Query } from "../define/Query.ts";
+import { Driver } from "../lib/Driver.ts";
+import { SqlError } from "../lib/SqlError.ts";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.ts";
+import { SqliteSchema } from "../sqlite/SqliteSchema.ts";
+var PreparedStatement = class {
+  constructor(lastChanges, stmt) {
+    this.lastChanges = lastChanges;
+    this.stmt = stmt;
+  }
+  *iterate(params = []) {
+    for (const row of this.stmt.all(...params))
+      yield row;
+  }
+  all(params = []) {
+    return this.stmt.all(...params);
+  }
+  run(params = []) {
+    this.stmt.run(...params);
+    return this.lastChanges();
+  }
+  get(params = []) {
+    return this.stmt.get(...params);
+  }
+  execute(params = []) {
+    this.stmt.run(...params);
+  }
+};
+var BunSqliteDriver = class extends Driver.Sync {
+  constructor(db) {
+    super(new SqliteFormatter());
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+    this.lastChanges = this.prepare(() => {
+      return new Cursor.SelectSingle(
+        Query.Raw({
+          expectedReturn: "row",
+          strings: ["SELECT changes() as rowsAffected"],
+          params: []
+        })
+      );
+    });
+  }
+  tableData;
+  indexData;
+  lastChanges;
+  prepareStatement(stmt) {
+    try {
+      return new PreparedStatement(this.lastChanges, this.db.prepare(stmt.sql));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+};
+function connect(db) {
+  return new BunSqliteDriver(db);
+}
+export {
+  BunSqliteDriver,
+  connect
+};

package/dist/deno/driver/sql.js.js

@@ -0,0 +1,72 @@
+// src/driver/sql.js.ts
+import { Driver } from "../lib/Driver.ts";
+import { SqlError } from "../lib/SqlError.ts";
+import { SqliteFormatter } from "../sqlite/SqliteFormatter.ts";
+import { SqliteSchema } from "../sqlite/SqliteSchema.ts";
+var PreparedStatement = class {
+  constructor(db, stmt, discardAfter) {
+    this.db = db;
+    this.stmt = stmt;
+    this.discardAfter = discardAfter;
+  }
+  *iterate(params) {
+    this.stmt.bind(params);
+    while (this.stmt.step())
+      yield this.stmt.getAsObject();
+    if (this.discardAfter)
+      this.stmt.free();
+  }
+  all(params) {
+    return Array.from(this.iterate(params));
+  }
+  run(params) {
+    this.stmt.run(params);
+    if (this.discardAfter)
+      this.stmt.free();
+    return { rowsAffected: this.db.getRowsModified() };
+  }
+  get(params) {
+    return this.all(params)[0];
+  }
+  execute(params) {
+    this.stmt.run(params);
+    if (this.discardAfter)
+      this.stmt.free();
+  }
+};
+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;
+  prepareStatement(stmt, discardAfter) {
+    try {
+      return new PreparedStatement(
+        this.db,
+        this.db.prepare(stmt.sql),
+        discardAfter
+      );
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
+  }
+  schemaInstructions(tableName) {
+    const columnData = this.tableData(tableName);
+    const indexData = this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  export() {
+    return this.db.export();
+  }
+};
+function connect(db) {
+  return new SqlJsDriver(db);
+}
+export {
+  SqlJsDriver,
+  connect
+};