rado 0.1.30 → 0.1.32

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export * from './lib/Driver';
 export * from './lib/Expr';
 export * from './lib/Fields';
 export * from './lib/Formatter';
-export * from './lib/Functions';
+export { Functions } from './lib/Functions';
 export * from './lib/Id';
 export * from './lib/Index';
 export * from './lib/Ops';

package/dist/index.js

@@ -5,7 +5,7 @@ export * from "./lib/Driver.js";
 export * from "./lib/Expr.js";
 export * from "./lib/Fields.js";
 export * from "./lib/Formatter.js";
-export * from "./lib/Functions.js";
+import { Functions } from "./lib/Functions.js";
 export * from "./lib/Id.js";
 export * from "./lib/Index.js";
 export * from "./lib/Ops.js";
@@ -19,3 +19,6 @@ export * from "./lib/Statement.js";
 export * from "./lib/Table.js";
 export * from "./lib/Target.js";
 export * from "./lib/Update.js";
+export {
+  Functions
+};

package/dist/lib/Formatter.js

@@ -537,6 +537,9 @@ var Formatter = class {
           this.formatExprValue(ctx, e).add("as").space();
           this.formatString(ctx, typeName);
           return stmt.closeParenthesis();
+        } else if (expr.method === "exists") {
+          stmt.raw("exists").space();
+          return this.formatExprValue(ctx, expr.params[0]);
         } else {
           stmt.addIdentifier(expr.method).openParenthesis();
           for (const param of stmt.separate(expr.params))

package/dist/lib/Functions.d.ts

@@ -1,7 +1,5 @@
-import { EV, Expr } from './Expr';
+import { Expr } from './Expr';
 export declare const Functions: Functions;
-/** These will have to be supported in every driver */
 export type Functions = {
-    count(x?: Expr<any>): Expr<number>;
-    iif<T>(x: EV<boolean>, y: EV<T>, z: EV<T>): Expr<T>;
+    [key: string]: (...args: Array<any>) => Expr<any>;
 };

package/dist/lib/Table.d.ts

@@ -9,6 +9,9 @@ import { Update } from './Update';
 export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
     [Selection.__tableType](): Table.Normalize<T>;
     constructor(schema: Schema);
+    fetch(id: EV<T extends {
+        id: Column.IsPrimary<infer V, any>;
+    } ? V : never>): Cursor.SelectSingle<Table.Normalize<T> | undefined>;
     insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
     insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
     set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;

package/dist/lib/Table.js

@@ -32,6 +32,9 @@ var Table = class extends Cursor.SelectMultiple {
       }
     });
   }
+  fetch(id) {
+    return this.where(this.get("id").is(id)).first();
+  }
   insertOne(record) {
     return new Cursor(
       Query.Insert({

package/dist/sqlite/SqliteFunctions.d.ts

@@ -1,7 +1,16 @@
+import { Cursor } from '../lib/Cursor';
 import { EV, Expr } from '../lib/Expr';
 import { Table } from '../lib/Table';
 export declare const SqliteFunctions: SqliteFunctions;
 export type SqliteFunctions = {
+    /** The count(X) function returns a count of the number of times that X is not NULL in a group. The count(*) function (with no arguments) returns the total number of rows in the group. */
+    count(x?: Expr<any>): Expr<number>;
+    /** The iif(X,Y,Z) function returns the value Y if X is true, and Z otherwise. The iif(X,Y,Z) function is logically equivalent to and generates the same bytecode as the CASE Expr "CASE WHEN X THEN Y ELSE Z END".*/
+    iif<T>(x: EV<boolean>, y: EV<T>, z: EV<T>): Expr<T>;
+    /**
+     * The EXISTS operator always evaluates to one of the integer values 0 and 1. If executing the SELECT statement specified as the right-hand operand of the EXISTS operator would return one or more rows, then the EXISTS operator evaluates to 1. If executing the SELECT would return no rows at all, then the EXISTS operator evaluates to 0.
+     */
+    exists(cursor: Cursor<any>): Expr<boolean>;
     /** Use the match operator for the FTS5 module */
     match(table: Table<any>, searchTerm: EV<string>): Expr<boolean>;
     cast(x: EV<any>, type: 'text'): Expr<string>;
@@ -19,8 +28,6 @@ export type SqliteFunctions = {
     /** The hex() function numbererprets its argument as a BLOB and returns a string which is the upper-case hexadecimal rendering of the content of that blob. If the argument X in "hex(X)" is an numbereger or numbering ponumber number, then "numbererprets its argument as a BLOB" means that the binary number is first converted numbero a UTF8 text representation, then that text is numbererpreted as a BLOB. Hence, "hex(12345678)" renders as "3132333435363738" not the binary representation of the numbereger value "0000000000BC614E".*/
     /** The ifnull() function returns a copy of its first non-NULL argument, or NULL if both arguments are NULL. Ifnull() must have exactly 2 arguments. The ifnull() function is equivalent to coalesce() with two arguments.*/
     ifnull<T>(x: EV<T>, y: EV<T>): Expr<T>;
-    /** The iif(X,Y,Z) function returns the value Y if X is true, and Z otherwise. The iif(X,Y,Z) function is logically equivalent to and generates the same bytecode as the CASE Expr "CASE WHEN X THEN Y ELSE Z END".*/
-    iif<T>(x: EV<boolean>, y: EV<T>, z: EV<T>): Expr<T>;
     /** The instr(X,Y) function finds the first occurrence of string Y within string X and returns the number of prior characters plus 1, or 0 if Y is nowhere found within X. Or, if X and Y are both BLOBs, then instr(X,Y) returns one more than the number bytes prior to the first occurrence of Y, or 0 if Y does not occur anywhere within X. If both arguments X and Y to instr(X,Y) are non-NULL and are not BLOBs then both are numbererpreted as strings. If either X or Y are NULL in instr(X,Y) then the result is NULL.*/
     instr(x: EV<string>, y: EV<string>): Expr<number>;
     /** The last_insert_rowid() function returns the ROWID of the last row insert from the database connection which invoked the function. The last_insert_rowid() SQL function is a wrapper around the sqlite3_last_insert_rowid() C/C++ numbererface function.*/
@@ -76,8 +83,6 @@ export type SqliteFunctions = {
     upper(x: EV<string>): Expr<string>;
     /** The avg() function returns the average value of all non-NULL X within a group. string and BLOB values that do not look like numbers are numbererpreted as 0. The result of avg() is always a numbering ponumber value as long as at there is at least one non-NULL input even if all inputs are numberegers. The result of avg() is NULL if and only if there are no non-NULL inputs. */
     avg(x: Expr<number>): Expr<number>;
-    /** The count(X) function returns a count of the number of times that X is not NULL in a group. The count(*) function (with no arguments) returns the total number of rows in the group. */
-    count(x?: Expr<any>): Expr<number>;
     /** The group_concat() function returns a string which is the concatenation of all non-NULL values of X. If parameter Y is present then it is used as the separator between instances of X. A comma (",") is used as the separator if Y is omitted. The order of the concatenated elements is arbitrary. */
     group_concat(x: EV<string>, y: EV<string>): Expr<string>;
     /** The sum() and total() aggregate functions return sum of all non-NULL values in the group. If there are no non-NULL input rows then sum() returns NULL but total() returns 0.0. NULL is not normally a helpful result for the sum of no rows but the SQL standard requires it and most other SQL database engines implement sum() that way so SQLite does it in the same way in order to be compatible. The non-standard total() function is provided as a convenient way to work around this design problem in the SQL language.
@@ -148,9 +153,9 @@ export type SqliteFunctions = {
     julianday(timeValue: EV<any>, ...rest: Array<EV<string>>): Expr<string>;
     strftime(format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>): Expr<string>;
 };
-export declare const match: (table: Table<any>, searchTerm: EV<string>) => Expr<boolean>, cast: {
+export declare const count: (x?: Expr<any>) => Expr<number>, iif: <T>(x: EV<boolean>, y: EV<T>, z: EV<T>) => Expr<T>, exists: (cursor: Cursor<any>) => Expr<boolean>, match: (table: Table<any>, searchTerm: EV<string>) => Expr<boolean>, cast: {
     (x: EV<any>, type: 'text'): Expr<string>;
     (x: EV<any>, type: 'real'): Expr<number>;
     (x: EV<any>, type: 'integer'): Expr<number>;
     (x: EV<any>, type: 'numeric'): Expr<number>;
-}, abs: (x: EV<number>) => Expr<number>, changes: () => Expr<number>, char: (...arg: Array<EV<number>>) => Expr<string>, coalesce: (x: EV<any>, y: EV<any>, ...rest: EV<any>) => Expr<any>, ifnull: <T>(x: EV<T>, y: EV<T>) => Expr<T>, iif: <T>(x: EV<boolean>, y: EV<T>, z: EV<T>) => Expr<T>, instr: (x: EV<string>, y: EV<string>) => Expr<number>, last_insert_rowid: () => Expr<number>, length: (x: EV<string>) => Expr<number>, likelihood: (x: EV<boolean>, y: number) => Expr<boolean>, likely: (x: EV<boolean>) => Expr<boolean>, lower: (x: EV<string>) => Expr<string>, ltrim: (x: EV<string>, y?: EV<string>) => Expr<string>, max: <T>(x: EV<T>, y: EV<T>, ...rest: EV<T>[]) => Expr<T>, min: <T>(x: EV<T>, y: EV<T>, ...rest: EV<T>[]) => Expr<T>, nullif: <T>(x: EV<T>, y: EV<T>) => Expr<T | null>, prnumberf: (format: string, ...rest: Array<Expr<any>>) => Expr<string>, quote: (x: EV<string>) => Expr<string>, random: () => Expr<number>, replace: (x: EV<string>, y: EV<string>, z: EV<string>) => Expr<string>, round: (x: EV<number>, y?: EV<number>) => Expr<number>, rtrim: (x: EV<string>, y?: EV<string>) => Expr<string>, sign: (x: EV<number>) => Expr<number>, soundex: (x: EV<string>) => Expr<string>, sqlite_version: () => Expr<string>, substr: (x: EV<string>, y: EV<number>, z?: EV<number>) => Expr<string>, total_changes: () => Expr<number>, trim: (x: EV<string>, Y: EV<string>) => Expr<string>, unicode: (x: EV<string>) => Expr<number>, unlikely: (x: EV<boolean>) => Expr<boolean>, upper: (x: EV<string>) => Expr<string>, avg: (x: Expr<number>) => Expr<number>, count: (x?: Expr<any>) => Expr<number>, group_concat: (x: EV<string>, y: EV<string>) => Expr<string>, sum: (x: EV<number>) => Expr<number>, acos: (x: EV<number>) => Expr<number>, acosh: (x: EV<number>) => Expr<number>, asin: (x: EV<number>) => Expr<number>, asinh: (x: EV<number>) => Expr<number>, atan: (x: EV<number>) => Expr<number>, atan2: (x: EV<number>, y: EV<number>) => Expr<number>, atanh: (x: EV<number>) => Expr<number>, ceil: (x: EV<number>) => Expr<number>, cos: (x: EV<number>) => Expr<number>, cosh: (x: EV<number>) => Expr<number>, degrees: (x: EV<number>) => Expr<number>, exp: (x: EV<number>) => Expr<number>, floor: (x: EV<number>) => Expr<number>, ln: (x: EV<number>) => Expr<number>, log: (x: EV<number>, y?: EV<number>) => Expr<number>, log2: (x: EV<number>) => Expr<number>, mod: (x: EV<number>, y: EV<number>) => Expr<number>, pi: (x: EV<number>) => Expr<number>, pow: (x: EV<number>, y: EV<number>) => Expr<number>, radians: (x: EV<number>) => Expr<number>, sin: (x: EV<number>) => Expr<number>, sinh: (x: EV<number>) => Expr<number>, sqrt: (x: EV<number>) => Expr<number>, tan: (x: EV<number>) => Expr<number>, tanh: (x: EV<number>) => Expr<number>, trunc: (x: EV<number>) => Expr<number>, date: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, time: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, datetime: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, julianday: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, strftime: (format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>;
+}, abs: (x: EV<number>) => Expr<number>, changes: () => Expr<number>, char: (...arg: Array<EV<number>>) => Expr<string>, coalesce: (x: EV<any>, y: EV<any>, ...rest: EV<any>) => Expr<any>, ifnull: <T>(x: EV<T>, y: EV<T>) => Expr<T>, instr: (x: EV<string>, y: EV<string>) => Expr<number>, last_insert_rowid: () => Expr<number>, length: (x: EV<string>) => Expr<number>, likelihood: (x: EV<boolean>, y: number) => Expr<boolean>, likely: (x: EV<boolean>) => Expr<boolean>, lower: (x: EV<string>) => Expr<string>, ltrim: (x: EV<string>, y?: EV<string>) => Expr<string>, max: <T>(x: EV<T>, y: EV<T>, ...rest: EV<T>[]) => Expr<T>, min: <T>(x: EV<T>, y: EV<T>, ...rest: EV<T>[]) => Expr<T>, nullif: <T>(x: EV<T>, y: EV<T>) => Expr<T | null>, prnumberf: (format: string, ...rest: Array<Expr<any>>) => Expr<string>, quote: (x: EV<string>) => Expr<string>, random: () => Expr<number>, replace: (x: EV<string>, y: EV<string>, z: EV<string>) => Expr<string>, round: (x: EV<number>, y?: EV<number>) => Expr<number>, rtrim: (x: EV<string>, y?: EV<string>) => Expr<string>, sign: (x: EV<number>) => Expr<number>, soundex: (x: EV<string>) => Expr<string>, sqlite_version: () => Expr<string>, substr: (x: EV<string>, y: EV<number>, z?: EV<number>) => Expr<string>, total_changes: () => Expr<number>, trim: (x: EV<string>, Y: EV<string>) => Expr<string>, unicode: (x: EV<string>) => Expr<number>, unlikely: (x: EV<boolean>) => Expr<boolean>, upper: (x: EV<string>) => Expr<string>, avg: (x: Expr<number>) => Expr<number>, group_concat: (x: EV<string>, y: EV<string>) => Expr<string>, sum: (x: EV<number>) => Expr<number>, acos: (x: EV<number>) => Expr<number>, acosh: (x: EV<number>) => Expr<number>, asin: (x: EV<number>) => Expr<number>, asinh: (x: EV<number>) => Expr<number>, atan: (x: EV<number>) => Expr<number>, atan2: (x: EV<number>, y: EV<number>) => Expr<number>, atanh: (x: EV<number>) => Expr<number>, ceil: (x: EV<number>) => Expr<number>, cos: (x: EV<number>) => Expr<number>, cosh: (x: EV<number>) => Expr<number>, degrees: (x: EV<number>) => Expr<number>, exp: (x: EV<number>) => Expr<number>, floor: (x: EV<number>) => Expr<number>, ln: (x: EV<number>) => Expr<number>, log: (x: EV<number>, y?: EV<number>) => Expr<number>, log2: (x: EV<number>) => Expr<number>, mod: (x: EV<number>, y: EV<number>) => Expr<number>, pi: (x: EV<number>) => Expr<number>, pow: (x: EV<number>, y: EV<number>) => Expr<number>, radians: (x: EV<number>) => Expr<number>, sin: (x: EV<number>) => Expr<number>, sinh: (x: EV<number>) => Expr<number>, sqrt: (x: EV<number>) => Expr<number>, tan: (x: EV<number>) => Expr<number>, tanh: (x: EV<number>) => Expr<number>, trunc: (x: EV<number>) => Expr<number>, date: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, time: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, datetime: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, julianday: (timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>, strftime: (format: EV<string>, timeValue: EV<any>, ...rest: Array<EV<string>>) => Expr<string>;

package/dist/sqlite/SqliteFunctions.js

@@ -2,6 +2,9 @@
 import { Functions } from "../lib/Functions.js";
 var SqliteFunctions = Functions;
 var {
+  count,
+  iif,
+  exists,
   match,
   cast,
   abs,
@@ -9,7 +12,6 @@ var {
   char,
   coalesce,
   ifnull,
-  iif,
   instr,
   last_insert_rowid,
   length,
@@ -36,7 +38,6 @@ var {
   unlikely,
   upper,
   avg,
-  count,
   group_concat,
   sum,
   acos,
@@ -93,6 +94,7 @@ export {
   date,
   datetime,
   degrees,
+  exists,
   exp,
   floor,
   group_concat,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "license": "MIT",
   "type": "module",
   "exports": {