rado 0.1.29 → 0.1.31

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/Schema.js

@@ -1,5 +1,6 @@
 // src/lib/Schema.ts
 import { Query } from "./Query.js";
+import { Statement } from "./Statement.js";
 var Schema;
 ((Schema2) => {
   function create(schema) {
@@ -27,7 +28,10 @@ var Schema;
       } else if (!schemaCol) {
         res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
       } else {
-        const { sql: instruction } = formatter.formatColumn({ ...schemaCol, references: void 0 }).compile(formatter);
+        const { sql: instruction } = formatter.formatColumn(
+          { stmt: new Statement() },
+          { ...schemaCol, references: void 0 }
+        ).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
           res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
         }
@@ -46,6 +50,7 @@ var Schema;
         res.unshift(Query.DropIndex({ table: schema, name: indexName }));
       } else {
         const { sql: instruction } = formatter.formatCreateIndex(
+          { stmt: new Statement() },
           Query.CreateIndex({ table: schema, index: schemaIndex })
         ).compile(formatter);
         if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {

package/dist/lib/Statement.d.ts

@@ -25,30 +25,26 @@ export interface CompileOptions {
 }
 export declare class Statement {
     tokens: Array<Token>;
-    constructor(tokens: Array<Token>);
-    concat(...tokens: Array<Token | Statement>): Statement;
-    static create(from: string | Statement): Statement;
+    constructor(tokens?: Array<Token>);
+    concat(...tokens: Array<Token>): this;
     static tag(strings: ReadonlyArray<string>, params: Array<Statement>): Statement;
-    space(): Statement;
-    call(method: string, ...args: Array<Statement>): Statement;
-    addCall(method: string, ...args: Array<Statement>): Statement;
-    add(addition: undefined | string | Statement): Statement;
-    addLine(addition: undefined | string | Statement): Statement;
-    addIf(condition: any, addition: string | Statement | (() => string | Statement)): Statement;
-    indent(): Statement;
-    dedent(): Statement;
-    newline(ignore?: boolean): Statement;
-    identifier(name: string): Statement;
-    addIdentifier(name: string): Statement;
-    value(value: any): Statement;
-    addValue(value: any): Statement;
-    param(name: string): Statement;
-    addParam(name: string): Statement;
-    raw(query: string): Statement;
-    parenthesis(inner: string | Statement): Statement;
-    addParenthesis(stmnt: string | Statement): Statement;
-    separated(input: Array<Statement>, separator?: string): Statement;
-    addSeparated(input: Array<Statement>, separator?: string): Statement;
+    space(): this;
+    add(addition: undefined | string): this;
+    addLine(addition: undefined | string): this;
+    indent(): this;
+    dedent(): this;
+    newline(ignore?: boolean): this;
+    identifier(name: string): this;
+    addIdentifier(name: string): this;
+    value(value: any): this;
+    addValue(value: any): this;
+    param(name: string): this;
+    addParam(name: string): this;
+    raw(query: string): this;
+    openParenthesis(): this;
+    closeParenthesis(): this;
+    call<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
+    separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
     isEmpty(): boolean;
     compile(sanitizer: Sanitizer, formatInline?: boolean): CompiledStatement;
 }
@@ -60,13 +56,4 @@ export declare class CompiledStatement {
     params(input?: Record<string, any>): Array<any>;
     toString(): string;
 }
-export declare function newline(): Statement;
-export declare function raw(raw: string): Statement;
-export declare function identifier(name: string): Statement;
-export declare function value(value: any): Statement;
-export declare function param(name: string): Statement;
-export declare function empty(): Statement;
-export declare function parenthesis(stmnt: Statement): Statement;
-export declare function call(method: string, ...args: Array<Statement>): Statement;
-export declare function separated(input: Array<Statement>, separator?: string): Statement;
 export {};

package/dist/lib/Statement.js

@@ -24,58 +24,39 @@ var Token = class {
     return new Token("Param" /* Param */, name);
   }
 };
-var SEPARATE = ",";
+var SEPARATE = ", ";
 var WHITESPACE = " ";
 var NEWLINE = "\n";
 var Statement = class {
-  constructor(tokens) {
+  constructor(tokens = []) {
     this.tokens = tokens;
   }
   concat(...tokens) {
-    return new Statement(
-      this.tokens.concat(
-        ...tokens.flatMap((t) => t instanceof Statement ? t.tokens : [t])
-      )
-    );
-  }
-  static create(from) {
-    return typeof from === "string" ? raw(from) : from;
+    this.tokens.push(...tokens);
+    return this;
   }
   static tag(strings, params) {
     return new Statement(
       strings.flatMap((s, i) => {
-        const param2 = params[i];
-        return [Token.Raw(s)].concat(param2 ? param2.tokens : []);
+        const param = params[i];
+        return [Token.Raw(s)].concat(param ? param.tokens : []);
       })
     );
   }
   space() {
-    return this.concat(Token.Raw(WHITESPACE));
-  }
-  call(method, ...args) {
-    return this.identifier(method).parenthesis(separated(args));
-  }
-  addCall(method, ...args) {
-    return this.space().call(method, ...args);
+    if (this.tokens.length === 0)
+      return this;
+    return this.raw(WHITESPACE);
   }
   add(addition) {
     if (!addition)
       return this;
-    if (addition instanceof Statement && addition.isEmpty())
-      return this;
-    return this.space().concat(Statement.create(addition));
+    return this.space().raw(addition);
   }
   addLine(addition) {
     if (!addition)
       return this;
-    if (addition instanceof Statement && addition.isEmpty())
-      return this;
-    return this.newline().concat(Statement.create(addition));
-  }
-  addIf(condition, addition) {
-    if (!condition)
-      return this;
-    return this.add(typeof addition === "function" ? addition() : addition);
+    return this.newline().add(addition);
   }
   indent() {
     return this.concat(Token.Indent());
@@ -94,11 +75,11 @@ var Statement = class {
   addIdentifier(name) {
     return this.space().identifier(name);
   }
-  value(value2) {
-    return this.concat(Token.Value(value2));
+  value(value) {
+    return this.concat(Token.Value(value));
   }
-  addValue(value2) {
-    return this.space().value(value2);
+  addValue(value) {
+    return this.space().value(value);
   }
   param(name) {
     return this.concat(Token.Param(name));
@@ -111,21 +92,23 @@ var Statement = class {
       return this;
     return this.concat(Token.Raw(query));
   }
-  parenthesis(inner) {
-    return this.raw("(").indent().newline().concat(Statement.create(inner)).dedent().newline().raw(")");
+  openParenthesis() {
+    return this.raw("(").indent().newline();
   }
-  addParenthesis(stmnt) {
-    return this.space().parenthesis(stmnt);
+  closeParenthesis() {
+    return this.dedent().newline().raw(")");
   }
-  separated(input, separator = SEPARATE) {
-    return this.concat(
-      ...input.flatMap(
-        (stmt, i) => i === 0 ? stmt.tokens : [Token.Raw(separator), Token.Raw(NEWLINE), ...stmt.tokens]
-      )
-    );
+  *call(parts, separator = SEPARATE) {
+    this.openParenthesis();
+    yield* this.separate(parts, separator);
+    this.closeParenthesis();
   }
-  addSeparated(input, separator = SEPARATE) {
-    return this.space().separated(input, separator);
+  *separate(parts, separator = SEPARATE) {
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0)
+        this.raw(separator).newline();
+      yield parts[i];
+    }
   }
   isEmpty() {
     return this.tokens.length === 0 || this.tokens.length === 1 && this.tokens[0].type === "Raw" /* Raw */ && this.tokens[0].data === "";
@@ -173,56 +156,20 @@ var CompiledStatement = class {
     this.paramData = paramData;
   }
   params(input) {
-    return this.paramData.map((param2) => {
-      if (param2.type === ParamType.Named) {
-        if (input && param2.name in input)
-          return this.sanitizer.formatParamValue(input[param2.name]);
-        throw new TypeError(`Missing parameter ${param2.name}`);
+    return this.paramData.map((param) => {
+      if (param.type === ParamType.Named) {
+        if (input && param.name in input)
+          return this.sanitizer.formatParamValue(input[param.name]);
+        throw new TypeError(`Missing parameter ${param.name}`);
       }
-      return this.sanitizer.formatParamValue(param2.value);
+      return this.sanitizer.formatParamValue(param.value);
     });
   }
   toString() {
     return this.sql;
   }
 };
-function newline() {
-  return new Statement([Token.Raw(NEWLINE)]);
-}
-function raw(raw2) {
-  return new Statement([Token.Raw(raw2)]);
-}
-function identifier(name) {
-  return new Statement([Token.Identifier(name)]);
-}
-function value(value2) {
-  return new Statement([Token.Value(value2)]);
-}
-function param(name) {
-  return new Statement([Token.Param(name)]);
-}
-function empty() {
-  return new Statement([]);
-}
-function parenthesis(stmnt) {
-  return empty().parenthesis(stmnt);
-}
-function call(method, ...args) {
-  return identifier(method).parenthesis(separated(args));
-}
-function separated(input, separator = SEPARATE) {
-  return empty().separated(input, separator);
-}
 export {
   CompiledStatement,
-  Statement,
-  call,
-  empty,
-  identifier,
-  newline,
-  param,
-  parenthesis,
-  raw,
-  separated,
-  value
+  Statement
 };

package/dist/sqlite/SqliteFormatter.d.ts

@@ -6,7 +6,6 @@ export declare class SqliteFormatter extends Formatter {
     escapeValue(value: any): string;
     escapeIdentifier(input: string): string;
     escapeString(input: string): string;
-    formatSqlAccess(on: Statement, field: string): Statement;
-    formatJsonAccess(on: Statement, field: string): Statement;
-    formatExpr(expr: ExprData, ctx: FormatContext): Statement;
+    formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
 }

package/dist/sqlite/SqliteFormatter.js

@@ -1,7 +1,6 @@
 // src/sqlite/SqliteFormatter.ts
 import { ExprType } from "../lib/Expr.js";
 import { Formatter } from "../lib/Formatter.js";
-import { identifier } from "../lib/Statement.js";
 import { TargetType } from "../lib/Target.js";
 function escapeWithin(input, outer) {
   let buf = outer;
@@ -43,15 +42,14 @@ var SqliteFormatter = class extends Formatter {
   escapeString(input) {
     return escapeWithin(input, "'");
   }
-  formatSqlAccess(on, field) {
-    const target = this.formatString(`$.${field}`);
-    return on.raw("->>").concat(target);
+  formatAccess(ctx, mkSubject, field) {
+    const { stmt, formatAsJson } = ctx;
+    mkSubject();
+    stmt.raw(formatAsJson ? "->" : "->>");
+    return this.formatString(ctx, `$.${field}`);
   }
-  formatJsonAccess(on, field) {
-    const target = this.formatString(`$.${field}`);
-    return on.raw("->").concat(target);
-  }
-  formatExpr(expr, ctx) {
+  formatExpr(ctx, expr) {
+    const { stmt } = ctx;
     switch (expr.type) {
       case ExprType.Call:
         if (expr.method === "match") {
@@ -60,10 +58,12 @@ var SqliteFormatter = class extends Formatter {
             throw new Error("not implemented");
           if (from.target.type !== TargetType.Table)
             throw new Error("not implemented");
-          return identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ").concat(this.formatExprValue(query, ctx));
+          stmt.identifier(from.target.table.alias || from.target.table.name).raw(" MATCH ");
+          this.formatExprValue(ctx, query);
+          return stmt;
         }
       default:
-        return super.formatExpr(expr, ctx);
+        return super.formatExpr(ctx, expr);
     }
   }
 };

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/dist/sqlite/SqliteSchema.js

@@ -1,6 +1,6 @@
 // src/sqlite/SqliteSchema.ts
 import { Cursor } from "../lib/Cursor.js";
-import { identifier, raw } from "../lib/Statement.js";
+import { Statement } from "../lib/Statement.js";
 import { SqliteFormatter } from "./SqliteFormatter.js";
 var SqliteSchema;
 ((SqliteSchema2) => {
@@ -25,13 +25,16 @@ var SqliteSchema;
   }
   SqliteSchema2.createInstructions = createInstructions;
   function columnInstruction(column) {
-    return [
-      column.name,
-      identifier(column.name).add(column.type).addIf(column.pk === 1, "PRIMARY KEY").addIf(column.notnull === 1, "NOT NULL").addIf(
-        column.dflt_value !== null,
-        raw("DEFAULT").addParenthesis(column.dflt_value)
-      ).compile(formatter).sql
-    ];
+    const stmt = new Statement();
+    stmt.identifier(column.name).add(column.type);
+    if (column.pk === 1)
+      stmt.add("PRIMARY KEY");
+    if (column.notnull === 1)
+      stmt.add("NOT NULL");
+    if (column.dflt_value !== null) {
+      stmt.add("DEFAULT").space().openParenthesis().raw(column.dflt_value).closeParenthesis();
+    }
+    return [column.name, stmt.compile(formatter).sql];
   }
   SqliteSchema2.columnInstruction = columnInstruction;
   function indexInstruction(index) {

package/package.json

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