rado 0.3.2 → 0.3.4

package/dist/define/Table.d.ts

@@ -1,17 +1,17 @@
 import { Callable } from '../util/Callable.js';
 import { Column, ColumnData, OptionalColumn, PrimaryColumn } from './Column.js';
-import { EV, Expr } from './Expr.js';
+import { EV, Expr, ExprData } from './Expr.js';
 import type { Fields } from './Fields.js';
 import { Index, IndexData } from './Index.js';
+import { SelectFirst, TableSelect } from './Query.js';
 import type { Selection } from './Selection.js';
-import { SelectFirst } from './query/Select.js';
-import { TableSelect } from './query/TableSelect.js';
 export declare class TableData {
     name: string;
     alias?: string;
     definition: {};
     columns: Record<string, ColumnData>;
     meta: () => {
+        primaryKey?: Array<ExprData>;
         indexes: Record<string, IndexData>;
     };
     constructor(data: TableData);
@@ -43,6 +43,7 @@ type UpdateOf<Definition> = Partial<{
 export declare namespace Table {
     export const Data: unique symbol;
     export const Indexes: unique symbol;
+    export const PrimaryKey: unique symbol;
     export type Of<Row> = TableOf<Row>;
     export type Select<Definition> = RowOf<Definition>;
     export type Update<Definition> = UpdateOf<Definition>;
@@ -65,8 +66,10 @@ export declare function createTable<Definition>(data: TableData): Table<Definiti
 export declare function table<T extends {}, Indexes extends Record<string, Index>>(define: {
     [key: string]: T | Define<T>;
     [Table.Indexes]?: (this: T) => Indexes;
+    [Table.PrimaryKey]?: (this: T) => Array<Column<any>>;
 }): {} extends Indexes ? Table<T> : IndexedTable<T, keyof Indexes>;
 export declare namespace table {
     const indexes: typeof Table.Indexes;
+    const primaryKey: typeof Table.PrimaryKey;
 }
 export {};

package/dist/define/Table.js

@@ -3,8 +3,8 @@ import {
   ColumnType
 } from "./Column.js";
 import { BinOpType, Expr, ExprData } from "./Expr.js";
+import { TableSelect } from "./Query.js";
 import { Target } from "./Target.js";
-import { TableSelect } from "./query/TableSelect.js";
 const {
   assign,
   keys,
@@ -24,6 +24,7 @@ var Table;
 ((Table2) => {
   Table2.Data = Symbol("Table.Data");
   Table2.Indexes = Symbol("Table.Indexes");
+  Table2.PrimaryKey = Symbol("Table.PrimaryKey");
 })(Table || (Table = {}));
 function createTable(data) {
   const target = new Target.Table(data);
@@ -109,7 +110,10 @@ function table(define) {
       meta() {
         const createIndexes = define[Table.Indexes];
         const indexes = createIndexes ? createIndexes.apply(res) : {};
+        const createPrimaryKey = define[Table.PrimaryKey];
+        const primaryKey = createPrimaryKey ? createPrimaryKey.apply(res).map(ExprData.create) : void 0;
         return {
+          primaryKey,
           indexes: fromEntries(
             entries(indexes || {}).map(([key, index]) => {
               const indexName = `${name}.${key}`;
@@ -124,6 +128,7 @@ function table(define) {
 }
 ((table2) => {
   table2.indexes = Table.Indexes;
+  table2.primaryKey = Table.PrimaryKey;
 })(table || (table = {}));
 export {
   Table,

package/dist/define/VirtualTable.d.ts

@@ -2,10 +2,10 @@ import { Callable } from '../util/Callable.js';
 import { Column } from './Column.js';
 import { EV, Expr } from './Expr.js';
 import { Fields } from './Fields.js';
+import { Select } from './Query.js';
 import { Selection } from './Selection.js';
 import { Table } from './Table.js';
 import { Target } from './Target.js';
-import { Select } from './query/Select.js';
 export interface VirtualTableInstance<Definition> extends Callable {
     (conditions: {
         [K in keyof Definition]?: Definition[K] extends Expr<infer V> ? EV<V> : never;

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

@@ -1,5 +1,4 @@
 import { EV } from '../Expr.js';
-import { OrderBy } from '../OrderBy.js';
 import { Query, QueryData } from '../Query.js';
 export declare class Delete extends Query<{
     rowsAffected: number;
@@ -7,7 +6,6 @@ export declare class Delete extends Query<{
     [Query.Data]: QueryData.Delete;
     constructor(query: QueryData.Delete);
     where(...where: Array<EV<boolean>>): Delete;
-    orderBy(...orderBy: Array<OrderBy>): Delete;
     take(limit: number | undefined): Delete;
     skip(offset: number | undefined): Delete;
 }

package/dist/define/query/Delete.js

@@ -6,9 +6,6 @@ class Delete extends Query {
   where(...where) {
     return new Delete(this.addWhere(where));
   }
-  orderBy(...orderBy) {
-    return new Delete(this[Query.Data].with({ orderBy }));
-  }
   take(limit) {
     return new Delete(this[Query.Data].with({ limit }));
   }

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

@@ -1,5 +1,4 @@
 import { EV, Expr } from '../Expr.js';
-import { IndexData } from '../Index.js';
 import { OrderBy } from '../OrderBy.js';
 import { Query, QueryData } from '../Query.js';
 import { Selection } from '../Selection.js';
@@ -10,7 +9,6 @@ export declare class Select<Row> extends Union<Row> {
     [Query.Data]: QueryData.Select;
     constructor(query: QueryData.Select);
     from(table: Table<any> | VirtualTable<any>): Select<Row>;
-    indexedBy(index: IndexData): Select<unknown>;
     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>>;

package/dist/define/query/Select.js

@@ -2,7 +2,7 @@ import { Expr, ExprData } from "../Expr.js";
 import { Functions } from "../Functions.js";
 import { Query } from "../Query.js";
 import { Table } from "../Table.js";
-import { Target, TargetType } from "../Target.js";
+import { Target } from "../Target.js";
 import { VirtualTable } from "../VirtualTable.js";
 import { Union } from "./Union.js";
 function joinTarget(joinType, query, to, on) {
@@ -33,19 +33,6 @@ class Select extends Union {
       this[Query.Data].with({ from: virtual?.target || new Target.Table(table) })
     );
   }
-  indexedBy(index) {
-    const from = this[Query.Data].from;
-    switch (from?.type) {
-      case TargetType.Table:
-        return new Select(
-          this[Query.Data].with({
-            from: new Target.Table(from.table, index)
-          })
-        );
-      default:
-        throw new Error("Cannot index by without table target");
-    }
-  }
   leftJoin(that, ...on) {
     const query = this[Query.Data];
     return new Select(

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

package/dist/deno/driver/sqlite3.js

@@ -0,0 +1,123 @@
+// src/driver/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;
+  }
+  async *iterate(params) {
+    let rows = [], done = false, error;
+    let resolve;
+    let promise = new Promise((r) => resolve = r);
+    this.stmt.each(
+      params,
+      (err, row) => {
+        if (err)
+          error = err;
+        else
+          rows.push(row);
+        resolve();
+      },
+      () => {
+        done = true;
+        resolve();
+      }
+    );
+    while (true) {
+      const mustWait = !(rows.length || error || done);
+      if (mustWait)
+        await promise;
+      promise = new Promise((r) => resolve = r);
+      if (error)
+        throw error;
+      if (rows.length)
+        yield rows.shift();
+      if (done)
+        return;
+    }
+  }
+  all(params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.all(params, (err, rows) => {
+        if (err)
+          reject(err);
+        else
+          resolve(rows);
+      });
+    });
+  }
+  run(params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.run(params, function(err) {
+        if (err)
+          reject(err);
+        else
+          resolve({ rowsAffected: this.changes });
+      });
+    });
+  }
+  get(params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.get(params, (err, row) => {
+        if (err)
+          reject(err);
+        else
+          resolve(row);
+      });
+    });
+  }
+  execute(params) {
+    return new Promise((resolve, reject) => {
+      this.stmt.run(params, (err) => {
+        if (err)
+          reject(err);
+        else
+          resolve();
+      });
+    });
+  }
+};
+var Sqlite3Driver = class extends Driver.Async {
+  constructor(db) {
+    super(new SqliteFormatter());
+    this.db = db;
+    this.tableData = this.prepare(SqliteSchema.tableData);
+    this.indexData = this.prepare(SqliteSchema.indexData);
+  }
+  lock;
+  tableData;
+  indexData;
+  async executeQuery(query, stmt, params) {
+    await this.lock;
+    return super.executeQuery(query, stmt, params);
+  }
+  prepareStatement(stmt) {
+    try {
+      return new PreparedStatement(this.db.prepare(stmt.sql));
+    } catch (e) {
+      throw new SqlError(e, stmt.sql);
+    }
+  }
+  async schemaInstructions(tableName) {
+    const columnData = await this.tableData(tableName);
+    const indexData = await this.indexData(tableName);
+    return SqliteSchema.createInstructions(columnData, indexData);
+  }
+  isolate() {
+    const connection = new Sqlite3Driver(this.db);
+    let release, trigger = new Promise((resolve) => {
+      release = async () => resolve();
+    });
+    this.lock = Promise.resolve(this.lock).then(() => trigger);
+    return [connection, release];
+  }
+};
+function connect(db) {
+  return new Sqlite3Driver(db);
+}
+export {
+  Sqlite3Driver,
+  connect
+};

package/dist/deno/index.js

@@ -0,0 +1,14 @@
+// src/index.ts
+export * from "./define/Column.ts";
+export * from "./define/Cursor.ts";
+export * from "./define/Expr.ts";
+export * from "./define/Functions.ts";
+export * from "./define/Index.ts";
+export * from "./define/Ops.ts";
+export * from "./define/OrderBy.ts";
+export * from "./define/Param.ts";
+export * from "./define/Query.ts";
+export * from "./define/Schema.ts";
+export * from "./define/Table.ts";
+export * from "./define/Target.ts";
+export * from "./lib/SqlError.ts";