rado 0.4.9 → 1.0.0-preview.0

package/dist/sqlite/SqliteFunctions.d.ts

@@ -1,167 +1,8 @@
-import { EV, Expr } from '../define/Expr.js';
-import { Query } from '../define/Query.js';
-import { Table } from '../define/Table.js';
-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: Query<any>): Expr<boolean>;
-    /** Use the match operator for the FTS5 module */
-    match(table: Table<any>, searchTerm: EV<string>): Expr<boolean>;
-    /** Returns a real value reflecting the accuracy of the current match */
-    bm25(table: Table<any>, ...weights: Array<EV<number>>): Expr<number>;
-    /** The highlight() function returns a copy of the text from a specified column of the current row with extra markup text inserted to mark the start and end of phrase matches. */
-    highlight(table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>): Expr<string>;
-    /** The snippet() function is similar to highlight(), except that instead of returning entire column values, it automatically selects and extracts a short fragment of document text to process and return. */
-    snippet(table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>, snip: EV<string>, maxTokens: EV<number>): Expr<string>;
-    cast(x: EV<any>, type: 'text'): Expr<string>;
-    cast(x: EV<any>, type: 'real'): Expr<number>;
-    cast(x: EV<any>, type: 'integer'): Expr<number>;
-    cast(x: EV<any>, type: 'numeric'): Expr<number>;
-    /** The abs(X) function returns the absolute value of the numeric argument X. Abs(X) returns NULL if X is NULL. Abs(X) returns 0.0 if X is a string or blob that cannot be converted to a numeric value. If X is the numbereger -9223372036854775808 then abs(X) throws an numbereger overflow error since there is no equivalent positive 64-bit two complement value.*/
-    abs(x: EV<number>): Expr<number>;
-    /** The changes() function returns the number of database rows that were changed or inserted or deleted by the most recently completed INSERT, DELETE, or UPDATE statement, exclusive of statements in lower-level triggers. The changes() SQL function is a wrapper around the sqlite3_changes() C/C++ function and hence follows the same rules for counting changes.*/
-    changes(): Expr<number>;
-    /** The char(X1,X2,...,XN) function returns a string composed of characters having the unicode code ponumber values of numberegers X1 through XN, respectively.*/
-    char(...arg: Array<EV<number>>): Expr<string>;
-    /** The coalesce() function returns a copy of its first non-NULL argument, or NULL if all arguments are NULL. Coalesce() must have at least 2 arguments.*/
-    coalesce(x: EV<any>, y: EV<any>, ...rest: EV<any>): Expr<any>;
-    /** 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 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.*/
-    last_insert_rowid(): Expr<number>;
-    /** For a string value X, the length(X) function returns the number of characters (not bytes) in X prior to the first NUL character. Since SQLite strings do not normally contain NUL characters, the length(X) function will usually return the total number of characters in the string X. For a blob value X, length(X) returns the number of bytes in the blob. If X is NULL then length(X) is NULL. If X is numeric then length(X) returns the length of a string representation of X.*/
-    length(x: EV<string>): Expr<number>;
-    /** The likelihood(X,Y) function returns argument X unchanged. The value Y in likelihood(X,Y) must be a numbering ponumber constant between 0.0 and 1.0, inclusive. The likelihood(X) function is a no-op that the code generator optimizes away so that it consumes no CPU cycles during run-time (that is, during calls to sqlite3_step()). The purpose of the likelihood(X,Y) function is to provide a hnumber to the query planner that the argument X is a boolean that is true with a probability of approximately Y. The unlikely(X) function is short-hand for likelihood(X,0.0625). The likely(X) function is short-hand for likelihood(X,0.9375).*/
-    likelihood(x: EV<boolean>, y: number): Expr<boolean>;
-    /** The likely(X) function returns the argument X unchanged. The likely(X) function is a no-op that the code generator optimizes away so that it consumes no CPU cycles at run-time (that is, during calls to sqlite3_step()). The purpose of the likely(X) function is to provide a hnumber to the query planner that the argument X is a boolean value that is usually true. The likely(X) function is equivalent to likelihood(X,0.9375). See also: unlikely(X).*/
-    likely(x: EV<boolean>): Expr<boolean>;
-    /** The lower(X) function returns a copy of string X with all ASCII characters converted to lower case. The default built-in lower() function works for ASCII characters only. To do case conversions on non-ASCII characters, load the ICU extension.*/
-    lower(x: EV<string>): Expr<string>;
-    /** The ltrim(X,Y) function returns a string formed by removing any and all characters that appear in Y from the left side of X. If the Y argument is omitted, ltrim(X) removes spaces from the left side of X.**/
-    ltrim(x: EV<string>, y?: EV<string>): Expr<string>;
-    /** The multi-argument max() function returns the argument with the maximum value, or return NULL if any argument is NULL. The multi-argument max() function searches its arguments from left to right for an argument that defines a collating function and uses that collating function for all string comparisons. If none of the arguments to max() define a collating function, then the BINARY collating function is used. Note that max() is a simple function when it has 2 or more arguments but operates as an aggregate function if given only a single argument.*/
-    max<T>(x: EV<T>, ...rest: Array<EV<T>>): Expr<T>;
-    /** The multi-argument min() function returns the argument with the minimum value. The multi-argument min() function searches its arguments from left to right for an argument that defines a collating function and uses that collating function for all string comparisons. If none of the arguments to min() define a collating function, then the BINARY collating function is used. Note that min() is a simple function when it has 2 or more arguments but operates as an aggregate function if given only a single argument.*/
-    min<T>(x: EV<T>, ...rest: Array<EV<T>>): Expr<T>;
-    /** The nullif(X,Y) function returns its first argument if the arguments are different and NULL if the arguments are the same. The nullif(X,Y) function searches its arguments from left to right for an argument that defines a collating function and uses that collating function for all string comparisons. If neither argument to nullif() defines a collating function then the BINARY is used.*/
-    nullif<T>(x: EV<T>, y: EV<T>): Expr<T | null>;
-    /** The prnumberf(FORMAT,...) SQL function works like the sqlite3_mprnumberf() C-language function and the prnumberf() function from the standard C library. The first argument is a format string that specifies how to construct the output string using values taken from subsequent arguments. If the FORMAT argument is missing or NULL then the result is NULL. The %n format is silently ignored and does not consume an argument. The %p format is an alias for %X. The %z format is numbererchangeable with %s. If there are too few arguments in the argument list, missing arguments are assumed to have a NULL value, which is translated numbero 0 or 0.0 for numeric formats or an empty string for %s. See the built-in prnumberf() documentation for additional information.*/
-    prnumberf(format: string, ...rest: Array<Expr<any>>): Expr<string>;
-    /** The quote(X) function returns the text of an SQL literal which is the value of its argument suitable for inclusion numbero an SQL statement. strings are surrounded by single-quotes with escapes on numbererior quotes as needed. BLOBs are encoded as hexadecimal literals. strings with embedded NUL characters cannot be represented as string literals in SQL and hence the returned string literal is truncated prior to the first NUL.*/
-    quote(x: EV<string>): Expr<string>;
-    /** The random() function returns a pseudo-random numbereger between -9223372036854775808 and +9223372036854775807.*/
-    random(): Expr<number>;
-    /** The randomblob(N) function return an N-byte blob containing pseudo-random bytes. If N is less than 1 then a 1-byte random blob is returned.*/
-    /** The replace(X,Y,Z) function returns a string formed by substituting string Z for every occurrence of string Y in string X. The BINARY collating sequence is used for comparisons. If Y is an empty string then return X unchanged. If Z is not initially a string, it is cast to a UTF-8 string prior to processing.*/
-    replace(x: EV<string>, y: EV<string>, z: EV<string>): Expr<string>;
-    /** The round(X,Y) function returns a numbering-ponumber value X rounded to Y digits to the right of the decimal ponumber. If the Y argument is omitted, it is assumed to be 0.*/
-    round(x: EV<number>, y?: EV<number>): Expr<number>;
-    /** The rtrim(X,Y) function returns a string formed by removing any and all characters that appear in Y from the right side of X. If the Y argument is omitted, rtrim(X) removes spaces from the right side of X.*/
-    rtrim(x: EV<string>, y?: EV<string>): Expr<string>;
-    /** The sign(X) function returns -1, 0, or +1 if the argument X is a numeric value that is negative, zero, or positive, respectively. If the argument to sign(X) is NULL or is a string or blob that cannot be losslessly converted numbero a number, then sign(X) return NULL.*/
-    sign(x: EV<number>): Expr<number>;
-    /** The soundex(X) function returns a string that is the soundex encoding of the string X. The string "?000" is returned if the argument is NULL or contains no ASCII alphabetic characters. This function is omitted from SQLite by default. It is only available if the SQLITE_SOUNDEX compile-time option is used when SQLite is built.*/
-    soundex(x: EV<string>): Expr<string>;
-    /** The sqlite_version() function returns the version string for the SQLite library that is running. This function is an SQL wrapper around the sqlite3_libversion() C-numbererface.*/
-    sqlite_version(): Expr<string>;
-    /** The substr(X,Y,Z) function returns a substring of input string X that begins with the Y-th character and which is Z characters long. If Z is omitted then substr(X,Y) returns all characters through the end of the string X beginning with the Y-th. The left-most character of X is number 1. If Y is negative then the first character of the substring is found by counting from the right rather than the left. If Z is negative then the abs(Z) characters preceding the Y-th character are returned. If X is a string then characters indices refer to actual UTF-8 characters. If X is a BLOB then the indices refer to bytes.*/
-    substr(x: EV<string>, y: EV<number>, z?: EV<number>): Expr<string>;
-    /** The total_changes() function returns the number of row changes caused by INSERT, UPDATE or DELETE statements since the current database connection was opened. This function is a wrapper around the sqlite3_total_changes() C/C++ numbererface.*/
-    total_changes(): Expr<number>;
-    /** The trim(X,Y) function returns a string formed by removing any and all characters that appear in Y from both ends of X. If the Y argument is omitted, trim(X) removes spaces from both ends of X.*/
-    trim(x: EV<string>, Y: EV<string>): Expr<string>;
-    /** The typeof(X) function returns a string that indicates the datatype of the Expr X: "null", "numbereger", "real", "text", or "blob".*/
-    typeof(x: EV<any>): Expr<string>;
-    /** The unicode(X) function returns the numeric unicode code ponumber corresponding to the first character of the string X. If the argument to unicode(X) is not a string then the result is undefined.*/
-    unicode(x: EV<string>): Expr<number>;
-    /** The unlikely(X) function returns the argument X unchanged. The unlikely(X) function is a no-op that the code generator optimizes away so that it consumes no CPU cycles at run-time (that is, during calls to sqlite3_step()). The purpose of the unlikely(X) function is to provide a hnumber to the query planner that the argument X is a boolean value that is usually not true. The unlikely(X) function is equivalent to likelihood(X, 0.0625).*/
-    unlikely(x: EV<boolean>): Expr<boolean>;
-    /** The upper(X) function returns a copy of input string X in which all lower-case ASCII characters are converted to their upper-case equivalent.*/
-    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 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.
-  
-      The result of total() is always a numbering ponumber value. The result of sum() is an numbereger value if all non-NULL inputs are numberegers. If any input to sum() is neither an numbereger or a NULL then sum() returns a numbering ponumber value which might be an approximation to the true sum.
-  
-      Sum() will throw an "numbereger overflow" exception if all inputs are numberegers or NULL and an numbereger overflow occurs at any ponumber during the computation. Total() never throws an numbereger overflow.
-     */
-    sum(x: EV<number>): Expr<number>;
-    /** Return the arccosine of X. The result is in radians. */
-    acos(x: EV<number>): Expr<number>;
-    /** Return the hyperbolic arccosine of X. */
-    acosh(x: EV<number>): Expr<number>;
-    /** Return the arcsine of X. The result is in radians. */
-    asin(x: EV<number>): Expr<number>;
-    /** Return the hyperbolic arcsine of X. */
-    asinh(x: EV<number>): Expr<number>;
-    /** Return the arctangent of X. The result is in radians. */
-    atan(x: EV<number>): Expr<number>;
-    /** Return the arctangent of Y/X. The result is in radians. The result is placed numbero correct quadrant depending on the signs of X and Y. */
-    atan2(x: EV<number>, y: EV<number>): Expr<number>;
-    /** Return the hyperbolic arctangent of X. */
-    atanh(x: EV<number>): Expr<number>;
-    /** Return the first representable numbereger value greater than or equal to X. For positive values of X, this routine rounds away from zero. For negative values of X, this routine rounds toward zero. */
-    ceil(x: EV<number>): Expr<number>;
-    /** Return the cosine of X. X is in radians. */
-    cos(x: EV<number>): Expr<number>;
-    /** Return the hyperbolic cosine of X. */
-    cosh(x: EV<number>): Expr<number>;
-    /** Convert value X from radians numbero degrees. */
-    degrees(x: EV<number>): Expr<number>;
-    /** Compute e (Euler's number, approximately 2.71828182845905) raised to the power X. */
-    exp(x: EV<number>): Expr<number>;
-    /** Return the first representable numbereger value less than or equal to X. For positive numbers, this function rounds toward zero. For negative numbers, this function rounds away from zero. */
-    floor(x: EV<number>): Expr<number>;
-    /** Return the natural logarithm of X. */
-    ln(x: EV<number>): Expr<number>;
-    /**
-      Return the base-10 logarithm for X. Or, for the two-argument version, return the base-B logarithm of X.
-      Compatibility note: SQLite works like PostgreSQL in that the log() function computes a base-10 logarithm. Most other SQL database engines compute a natural logarithm for log(). In the two-argument version of log(B,X), the first argument is the base and the second argument is the operand. This is the same as in PostgreSQL and MySQL, but is reversed from SQL Server which uses the second argument as the base and the first argument as the operand.
-     */
-    log(x: EV<number>, y?: EV<number>): Expr<number>;
-    /** Return the logarithm base-2 for the number X. */
-    log2(x: EV<number>): Expr<number>;
-    /** Return the remainder after dividing X by Y. This is similar to the '%' operator, except that it works for non-numbereger arguments. */
-    mod(x: EV<number>, y: EV<number>): Expr<number>;
-    /** Return an approximation for π. */
-    pi(): Expr<number>;
-    /** Compute X raised to the power Y. */
-    pow(x: EV<number>, y: EV<number>): Expr<number>;
-    /** Convert X from degrees numbero radians. */
-    radians(x: EV<number>): Expr<number>;
-    /** Return the sine of X. X is in radians. */
-    sin(x: EV<number>): Expr<number>;
-    /** Return the hyperbolic sine of X. */
-    sinh(x: EV<number>): Expr<number>;
-    /** Return the square root of X. NULL is returned if X is negative. */
-    sqrt(x: EV<number>): Expr<number>;
-    /** Return the tangent of X. X is in radians. */
-    tan(x: EV<number>): Expr<number>;
-    /** Return the hyperbolic tangent of X. */
-    tanh(x: EV<number>): Expr<number>;
-    /** Return the representable numbereger in between X and 0 (inclusive) that is furthest away from zero. Or, in other words, return the numbereger part of X, rounding toward zero. The trunc() function is similar to ceiling(X) and floor(X) except that it always rounds toward zero whereas ceiling(X) and floor(X) round up and down, respectively. */
-    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>;
-};
-export declare const count: (x?: Expr<any>) => Expr<number>, iif: <T>(x: EV<boolean>, y: EV<T>, z: EV<T>) => Expr<T>, exists: (cursor: Query<any>) => Expr<boolean>, match: (table: Table<any>, searchTerm: EV<string>) => Expr<boolean>, bm25: (table: Table<any>, ...weights: Array<EV<number>>) => Expr<number>, highlight: (table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>) => Expr<string>, snippet: (table: Table<any>, index: EV<number>, insertBefore: EV<string>, insertAfter: EV<string>, snip: EV<string>, maxTokens: EV<number>) => Expr<string>, 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>, 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>, ...rest: EV<T>[]) => Expr<T>, min: <T>(x: 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: () => 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>;
+import type { HasQuery, HasSql, HasTable } from '../core/Internal.ts';
+import { type Sql } from '../core/Sql.ts';
+import { type Input } from '../core/expr/Input.ts';
+export declare const count: (x?: HasSql) => Sql<number>, iif: <T>(x: Input<boolean>, y: Input<T>, z: Input<T>) => Sql<T>, exists: (cursor: HasQuery) => Sql<boolean>, match: (table: HasTable, searchTerm: Input<string>) => Sql<boolean>, bm25: (table: HasTable, ...weights: Array<Input<number>>) => Sql<number>, highlight: (table: HasTable, index: Input<number>, insertBefore: Input<string>, insertAfter: Input<string>) => Sql<string>, snippet: (table: HasTable, index: Input<number>, insertBefore: Input<string>, insertAfter: Input<string>, snip: Input<string>, maxTokens: Input<number>) => Sql<string>, abs: (x: Input<number>) => Sql<number>, changes: () => Sql<number>, char: (...arg: Array<Input<number>>) => Sql<string>, coalesce: (x: Input, y: Input, ...rest: Array<Input>) => Sql, ifnull: <T>(x: Input<T>, y: Input<T>) => Sql<T>, instr: (x: Input<string>, y: Input<string>) => Sql<number>, last_insert_rowid: () => Sql<number>, length: (x: Input<string>) => Sql<number>, likelihood: (x: Input<boolean>, y: number) => Sql<boolean>, likely: (x: Input<boolean>) => Sql<boolean>, lower: (x: Input<string>) => Sql<string>, ltrim: (x: Input<string>, y?: Input<string>) => Sql<string>, max: <T>(x: Input<T>, ...rest: Array<Input<T>>) => Sql<T>, min: <T>(x: Input<T>, ...rest: Array<Input<T>>) => Sql<T>, nullif: <T>(x: Input<T>, y: Input<T>) => Sql<T | null>, prnumberf: (format: string, ...rest: Array<HasSql>) => Sql<string>, quote: (x: Input<string>) => Sql<string>, random: () => Sql<number>, replace: (x: Input<string>, y: Input<string>, z: Input<string>) => Sql<string>, round: (x: Input<number>, y?: Input<number>) => Sql<number>, rtrim: (x: Input<string>, y?: Input<string>) => Sql<string>, sign: (x: Input<number>) => Sql<number>, soundex: (x: Input<string>) => Sql<string>, sqlite_version: () => Sql<string>, substr: (x: Input<string>, y: Input<number>, z?: Input<number>) => Sql<string>, total_changes: () => Sql<number>, trim: (x: Input<string>, Y: Input<string>) => Sql<string>, unicode: (x: Input<string>) => Sql<number>, unlikely: (x: Input<boolean>) => Sql<boolean>, upper: (x: Input<string>) => Sql<string>, avg: (x: Sql<number>) => Sql<number>, group_concat: (x: Input<string>, y?: Input<string>) => Sql<string>, sum: (x: Input<number>) => Sql<number>, acos: (x: Input<number>) => Sql<number>, acosh: (x: Input<number>) => Sql<number>, asin: (x: Input<number>) => Sql<number>, asinh: (x: Input<number>) => Sql<number>, atan: (x: Input<number>) => Sql<number>, atan2: (x: Input<number>, y: Input<number>) => Sql<number>, atanh: (x: Input<number>) => Sql<number>, ceil: (x: Input<number>) => Sql<number>, cos: (x: Input<number>) => Sql<number>, cosh: (x: Input<number>) => Sql<number>, degrees: (x: Input<number>) => Sql<number>, exp: (x: Input<number>) => Sql<number>, floor: (x: Input<number>) => Sql<number>, ln: (x: Input<number>) => Sql<number>, log: (x: Input<number>, y?: Input<number>) => Sql<number>, log2: (x: Input<number>) => Sql<number>, mod: (x: Input<number>, y: Input<number>) => Sql<number>, pi: () => Sql<number>, pow: (x: Input<number>, y: Input<number>) => Sql<number>, radians: (x: Input<number>) => Sql<number>, sin: (x: Input<number>) => Sql<number>, sinh: (x: Input<number>) => Sql<number>, sqrt: (x: Input<number>) => Sql<number>, tan: (x: Input<number>) => Sql<number>, tanh: (x: Input<number>) => Sql<number>, trunc: (x: Input<number>) => Sql<number>, date: (timeValue: Input, ...rest: Array<Input<string>>) => Sql<string>, time: (timeValue: Input, ...rest: Array<Input<string>>) => Sql<string>, datetime: (timeValue: Input, ...rest: Array<Input<string>>) => Sql<string>, julianday: (timeValue: Input, ...rest: Array<Input<string>>) => Sql<string>, strftime: (format: Input<string>, timeValue: Input, ...rest: Array<Input<string>>) => Sql<string>;
+export declare function cast(x: Input, type: 'text'): Sql<string>;
+export declare function cast(x: Input, type: 'real'): Sql<number>;
+export declare function cast(x: Input, type: 'integer'): Sql<number>;
+export declare function cast(x: Input, type: 'numeric'): Sql<number>;

package/dist/sqlite/SqliteFunctions.js

@@ -1,4 +1,6 @@
-import { Functions } from "../define/Functions.js";
+import { sql } from "../core/Sql.ts";
+import { Functions } from "../core/expr/Functions.ts";
+import { input } from "../core/expr/Input.ts";
 const SqliteFunctions = Functions;
 const {
   count,
@@ -8,7 +10,6 @@ const {
   bm25,
   highlight,
   snippet,
-  cast,
   abs,
   changes,
   char,
@@ -74,8 +75,10 @@ const {
   julianday,
   strftime
 } = SqliteFunctions;
+function cast(x, type) {
+  return sql`cast(${input(x)} as ${sql.identifier(type)})`;
+}
 export {
-  SqliteFunctions,
   abs,
   acos,
   acosh,

package/dist/sqlite/SqliteTable.d.ts

@@ -0,0 +1 @@
+export { table as sqliteTable } from '../core/Table.ts';

package/dist/sqlite/SqliteTable.js

@@ -0,0 +1,4 @@
+import { table } from "../core/Table.ts";
+export {
+  table as sqliteTable
+};

package/dist/sqlite.d.ts

@@ -1,2 +1,3 @@
-export * from './sqlite/SqliteFormatter.js';
-export * from './sqlite/SqliteFunctions.js';
+export * from './sqlite/SqliteColumns.ts';
+export * from './sqlite/SqliteDialect.ts';
+export * from './sqlite/SqliteFunctions.ts';

package/dist/sqlite.js

@@ -1,2 +1,3 @@
-export * from "./sqlite/SqliteFormatter.js";
-export * from "./sqlite/SqliteFunctions.js";
+export * from "./sqlite/SqliteColumns.ts";
+export * from "./sqlite/SqliteDialect.ts";
+export * from "./sqlite/SqliteFunctions.ts";

package/dist/src/core/Builder.d.ts

@@ -0,0 +1,36 @@
+import { internalData, type HasQuery, type HasSql, type HasTable, type HasTarget } from './Internal.ts';
+import type { IsPostgres, QueryMeta } from './MetaData.ts';
+import type { QueryData } from './Query.ts';
+import type { SelectionInput } from './Selection.ts';
+import type { Table, TableDefinition } from './Table.ts';
+import { Create } from './query/CreateTable.ts';
+import { DeleteFrom } from './query/Delete.ts';
+import { Drop } from './query/DropTable.ts';
+import { InsertInto } from './query/Insert.ts';
+import type { SelectBase, WithSelection, WithoutSelection } from './query/Select.ts';
+import { UpdateTable } from './query/Update.ts';
+declare class BuilderBase<Meta extends QueryMeta> {
+    readonly [internalData]: QueryData<Meta>;
+    constructor(data: QueryData<Meta>);
+    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
+    dropTable(table: HasTable): Drop<Meta>;
+    select(): WithoutSelection<Meta>;
+    select<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
+    selectDistinct(): WithoutSelection<Meta>;
+    selectDistinct<Input extends SelectionInput>(selection: Input): WithSelection<Input, Meta>;
+    selectDistinctOn(this: Builder<IsPostgres>, columns: Array<HasSql>): WithoutSelection<Meta>;
+    selectDistinctOn<Input extends SelectionInput>(this: Builder<IsPostgres>, columns: Array<HasSql>, selection: Input): WithSelection<Input, Meta>;
+    update<Definition extends TableDefinition>(table: Table<Definition>): UpdateTable<Definition, Meta>;
+    insert<Definition extends TableDefinition>(into: Table<Definition>): InsertInto<Definition, Meta>;
+    delete(from: HasTable): DeleteFrom<Meta>;
+}
+export type CTE<Input = unknown> = Input & HasTarget & HasQuery;
+export declare class Builder<Meta extends QueryMeta> extends BuilderBase<Meta> {
+    $with(cteName: string): {
+        as<Input extends SelectionInput>(query: SelectBase<Input, Meta>): CTE<Input>;
+    };
+    with(...cte: Array<CTE>): BuilderBase<Meta>;
+    createTable<Definition extends TableDefinition>(table: Table<Definition>): Create<Meta>;
+    dropTable(table: HasTable): Drop<Meta>;
+}
+export {};

package/dist/src/core/Column.d.ts

@@ -0,0 +1,38 @@
+import type { HasColumn, HasSql } from './Internal.ts';
+import { internalColumn } from './Internal.ts';
+import type { Sql } from './Sql.ts';
+import type { Field, FieldData } from './expr/Field.ts';
+import { type Input } from './expr/Input.ts';
+export declare class ColumnData {
+    type: Sql;
+    name?: string;
+    json?: boolean;
+    primary?: boolean;
+    notNull?: boolean;
+    isUnique?: boolean;
+    autoIncrement?: boolean;
+    defaultValue?(): HasSql;
+    references?(): FieldData;
+    onUpdate?: HasSql;
+    onDelete?: HasSql;
+    mapFromDriverValue?(value: unknown): unknown;
+    mapToDriverValue?(value: unknown): unknown;
+}
+export declare class Column<Value = unknown> implements HasColumn {
+    readonly [internalColumn]: ColumnData;
+    constructor(data: ColumnData);
+    notNull(): RequiredColumn<NonNullable<Value>>;
+    default(value: Input<NonNullable<Value>> | (() => Input<NonNullable<Value>>)): Column<NonNullable<Value>>;
+    primaryKey(): Column<NonNullable<Value>>;
+    unique(name?: string): Column<Value>;
+    references(foreignField: Field | (() => Field)): Column<Value>;
+}
+export declare class JsonColumn<Value = unknown> extends Column<Value> {
+    private brand;
+    constructor(data: ColumnData);
+}
+declare const required: unique symbol;
+export interface RequiredColumn<Value = unknown> extends Column<Value> {
+    [required]: true;
+}
+export {};

package/dist/src/core/Constraint.d.ts

@@ -0,0 +1,39 @@
+import { internalConstraint, internalData, type HasConstraint, type HasData } from './Internal.ts';
+import type { Field, FieldData } from './expr/Field.ts';
+export interface UniqueConstraintData {
+    fields: Array<FieldData>;
+    nullsNotDistinct?: boolean;
+}
+export declare class UniqueConstraint<TableName extends string = string> implements HasData<UniqueConstraintData>, HasConstraint {
+    private brand;
+    [internalData]: UniqueConstraintData;
+    constructor(data: UniqueConstraintData);
+    on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): UniqueConstraint<TableName>;
+    nullsNotDistinct(): UniqueConstraint<string>;
+    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+}
+export declare function unique(): UniqueConstraint<string>;
+export interface PrimaryKeyConstraintData {
+    fields: Array<FieldData>;
+}
+export declare class PrimaryKeyConstraint<TableName extends string = string> implements HasData<PrimaryKeyConstraintData>, HasConstraint {
+    data: PrimaryKeyConstraintData;
+    private brand;
+    [internalData]: PrimaryKeyConstraintData;
+    constructor(data: PrimaryKeyConstraintData);
+    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+}
+export declare function primaryKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): PrimaryKeyConstraint<TableName>;
+export interface ForeignKeyConstraintData {
+    fields: Array<FieldData>;
+    references: Array<FieldData>;
+}
+export declare class ForeignKeyConstraint<TableName extends string = string> implements HasData<ForeignKeyConstraintData>, HasConstraint {
+    private brand;
+    [internalData]: ForeignKeyConstraintData;
+    constructor(data: ForeignKeyConstraintData);
+    references<ForeignTable extends string>(...fields: Array<Field<unknown, ForeignTable>>): ForeignKeyConstraint<TableName>;
+    get [internalConstraint](): import("./Sql.ts").Sql<unknown>;
+}
+export declare function foreignKey<TableName extends string = string>(...fields: Array<Field<unknown, TableName>>): ForeignKeyConstraint<TableName>;
+export type Constraint = UniqueConstraint | PrimaryKeyConstraint | ForeignKeyConstraint;

package/dist/src/core/Database.d.ts

@@ -0,0 +1,43 @@
+import { Builder } from './Builder.ts';
+import type { Dialect } from './Dialect.ts';
+import type { Driver } from './Driver.ts';
+import { internalResolver, type HasResolver } from './Internal.ts';
+import type { Async, Either, QueryDialect, QueryMeta, Sync } from './MetaData.ts';
+import { Resolver } from './Resolver.ts';
+export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
+    #private;
+    readonly [internalResolver]: Resolver<Meta>;
+    constructor(driver: Driver, dialect: Dialect, transactionDepth?: number);
+    close(this: Database<Async>): Promise<void>;
+    close(this: Database<Sync>): void;
+    [Symbol.dispose](this: Database<Sync>): void;
+    [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
+    transaction<T>(this: Database<Sync>, run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): T;
+    transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
+    transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): T | Promise<T>;
+}
+export interface TransactionOptions {
+    universal: never;
+    sqlite: {
+        behavior?: 'deferred' | 'immediate' | 'exclusive';
+    };
+    postgres: {
+        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+        accessMode?: 'read only' | 'read write';
+        deferrable?: boolean;
+    };
+    mysql: {
+        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+        accessMode?: 'read only' | 'read write';
+        withConsistentSnapshot?: boolean;
+    };
+}
+export declare class Rollback extends Error {
+}
+export declare class Transaction<Meta extends QueryMeta> extends Database<Meta> {
+    rollback(): never;
+}
+export declare class SyncDatabase<Dialect extends QueryDialect> extends Database<Sync<Dialect>> {
+}
+export declare class AsyncDatabase<Dialect extends QueryDialect> extends Database<Async<Dialect>> {
+}

package/dist/src/core/Dialect.d.ts

@@ -0,0 +1,6 @@
+import type { Emitter } from './Emitter.ts';
+import { type HasQuery, type HasSql } from './Internal.ts';
+export declare function dialect(createEmitter: {
+    new (): Emitter;
+}): (input: HasSql | HasQuery) => Emitter;
+export type Dialect = ReturnType<typeof dialect>;

package/dist/src/core/Driver.d.ts

@@ -0,0 +1,28 @@
+export type Driver = SyncDriver | AsyncDriver;
+export type Statement = SyncStatement | AsyncStatement;
+export interface SyncDriver {
+    close(): void;
+    exec(query: string): void;
+    prepare(query: string, name?: string): SyncStatement;
+    transaction<T>(run: (inner: SyncDriver) => T, options: unknown, depth: number): T;
+}
+export interface SyncStatement {
+    all(params: Array<unknown>): Array<object>;
+    run(params: Array<unknown>): void;
+    get(params: Array<unknown>): object | null;
+    values(params: Array<unknown>): Array<Array<unknown>>;
+    free(): void;
+}
+export interface AsyncDriver {
+    close(): Promise<void>;
+    exec(query: string): Promise<void>;
+    prepare(query: string, name?: string): AsyncStatement;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: unknown, depth: number): Promise<T>;
+}
+export interface AsyncStatement {
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object | null>;
+    values(params: Array<unknown>): Promise<Array<Array<unknown>>>;
+    free(): void;
+}

package/dist/src/core/Emitter.d.ts

@@ -0,0 +1,35 @@
+import type { ColumnData } from './Column.ts';
+import { type HasQuery, type HasTarget } from './Internal.ts';
+import { type Param } from './Param.ts';
+import type { FieldData } from './expr/Field.ts';
+import type { Create } from './query/CreateTable.ts';
+import type { Delete } from './query/Delete.ts';
+import type { Drop } from './query/DropTable.ts';
+import type { Insert } from './query/Insert.ts';
+import type { Select } from './query/Select.ts';
+import type { Union } from './query/Union.ts';
+import type { Update } from './query/Update.ts';
+export declare abstract class Emitter {
+    sql: string;
+    params: Array<Param>;
+    bind(inputs?: Record<string, unknown>): Array<unknown>;
+    abstract emitIdentifier(value: string): void;
+    abstract emitValue(value: unknown): void;
+    abstract emitInline(value: unknown): void;
+    abstract emitJsonPath(value: Array<number | string>): void;
+    abstract emitPlaceholder(value: string): void;
+    abstract emitDefaultValue(): void;
+    emitUnsafe(value: string): void;
+    emitField(field: FieldData): void;
+    emitCreateTable(create: Create): void;
+    emitDrop(drop: Drop): void;
+    emitColumn(column: ColumnData): void;
+    emitReferences(fields: Array<FieldData>): void;
+    emitDelete(deleteOp: Delete<unknown>): void;
+    emitInsert(insert: Insert<unknown>): void;
+    emitSelect(select: Select<unknown>): void;
+    emitUnion(union: Union<unknown>): void;
+    emitUpdate(update: Update<unknown>): void;
+    abstract emitIdColumn(): void;
+    emitWith(cte: Array<HasQuery & HasTarget>): void;
+}

package/dist/src/core/Index.d.ts

@@ -0,0 +1,28 @@
+import { internalData, type HasData, type HasSql } from './Internal.ts';
+import type { Field, FieldData } from './expr/Field.ts';
+export interface IndexData {
+    fields: Array<FieldData>;
+    unique?: boolean;
+    concurrently?: boolean;
+    only?: boolean;
+    using?: HasSql;
+    order?: 'asc' | 'desc';
+    nulls?: 'first' | 'last';
+    where?: HasSql;
+}
+export declare class Index<TableName extends string = string> implements HasData<IndexData> {
+    private brand;
+    [internalData]: IndexData;
+    constructor(data: IndexData);
+    on<TableName extends string>(...columns: Array<Field<unknown, TableName>>): Index<TableName>;
+    concurrently(): Index<string>;
+    only(): Index<string>;
+    using<Sql>(using: HasSql<Sql>): Index<string>;
+    asc(): Index<string>;
+    desc(): Index<string>;
+    nullsFirst(): Index<string>;
+    nullsLast(): Index<string>;
+    where(where: HasSql<boolean>): Index<string>;
+}
+export declare function index(): Index<string>;
+export declare function uniqueIndex(): Index<string>;

package/dist/src/core/Internal.d.ts

@@ -0,0 +1,67 @@
+import type { ColumnData } from './Column.ts';
+import type { QueryMeta } from './MetaData.ts';
+import type { Resolver } from './Resolver.ts';
+import type { Selection } from './Selection.ts';
+import type { Sql } from './Sql.ts';
+import type { TableApi, TableDefinition } from './Table.ts';
+import type { FieldData } from './expr/Field.ts';
+export declare const internalData: unique symbol;
+export declare const internalSql: unique symbol;
+export declare const internalSelection: unique symbol;
+export declare const internalTarget: unique symbol;
+export declare const internalQuery: unique symbol;
+export declare const internalTable: unique symbol;
+export declare const internalColumn: unique symbol;
+export declare const internalField: unique symbol;
+export declare const internalResolver: unique symbol;
+export declare const internalConstraint: unique symbol;
+export declare class HasData<Data> {
+    get [internalData](): Data;
+}
+export declare class HasSql<Value = unknown> {
+    get [internalSql](): Sql<Value>;
+}
+export declare class HasSelection {
+    get [internalSelection](): Selection;
+}
+export declare class HasTarget {
+    get [internalTarget](): Sql;
+}
+export declare class HasQuery {
+    get [internalQuery](): Sql;
+}
+export declare class HasTable<Definition extends TableDefinition = TableDefinition, Name extends string = string> {
+    get [internalTable](): TableApi<Definition, Name>;
+}
+export declare class HasColumn {
+    get [internalColumn](): ColumnData;
+}
+export declare class HasField {
+    get [internalField](): FieldData;
+}
+export declare class HasResolver<Meta extends QueryMeta = QueryMeta> {
+    get [internalResolver](): Resolver<Meta>;
+}
+export declare class HasConstraint {
+    get [internalConstraint](): Sql;
+}
+export declare const hasData: <Data>(obj: object) => obj is HasData<Data>;
+export declare const getData: <Data>(obj: HasData<Data>) => Data;
+export declare const hasSql: <Value>(obj: object) => obj is HasSql<Value>;
+export declare const getSql: <Value>(obj: HasSql<Value>) => Sql<Value>;
+export declare const hasSelection: (obj: object) => obj is HasSelection;
+export declare const getSelection: (obj: HasSelection) => Selection;
+export declare const hasTarget: (obj: object) => obj is HasTarget;
+export declare const getTarget: (obj: HasTarget) => Sql<unknown>;
+export declare const hasQuery: (obj: object) => obj is HasQuery;
+export declare const getQuery: (obj: HasQuery) => Sql<unknown>;
+export declare const hasTable: (obj: object) => obj is HasTable<TableDefinition, string>;
+export declare const getTable: (obj: HasTable) => TableApi<TableDefinition, string>;
+export declare const hasColumn: (obj: object) => obj is HasColumn;
+export declare const getColumn: (obj: HasColumn) => ColumnData;
+export declare const hasField: (obj: object) => obj is HasField;
+export declare const getField: (obj: HasField) => FieldData;
+export declare const hasResolver: <Meta extends QueryMeta>(obj: object) => obj is HasResolver<Meta>;
+export declare const getResolver: <Meta extends QueryMeta>(obj: HasResolver<Meta>) => Resolver<Meta>;
+export declare const hasConstraint: (obj: object) => obj is HasConstraint;
+export declare const getConstraint: (obj: HasConstraint) => Sql<unknown>;

package/dist/src/core/MetaData.d.ts

@@ -0,0 +1,27 @@
+export type QueryMode = 'sync' | 'async' | undefined;
+export type QueryDialect = 'universal' | 'sqlite' | 'mysql' | 'postgres';
+export interface QueryMeta {
+    mode: QueryMode;
+    dialect: QueryDialect;
+}
+export interface Sync<Dialect extends QueryDialect = QueryDialect> extends QueryMeta {
+    mode: 'sync';
+    dialect: Dialect;
+}
+export interface Async<Dialect extends QueryDialect = QueryDialect> extends QueryMeta {
+    mode: 'async';
+    dialect: Dialect;
+}
+export interface IsPostgres extends QueryMeta {
+    dialect: 'postgres';
+}
+export interface IsMysql extends QueryMeta {
+    dialect: 'mysql';
+}
+export interface IsSqlite extends QueryMeta {
+    dialect: 'sqlite';
+}
+export interface Either extends QueryMeta {
+    mode: 'sync' | 'async';
+    dialect: QueryDialect;
+}

package/dist/src/core/Param.d.ts

@@ -0,0 +1,9 @@
+export declare class NamedParam {
+    name: string;
+    constructor(name: string);
+}
+export declare class ValueParam {
+    value: unknown;
+    constructor(value: unknown);
+}
+export type Param = NamedParam | ValueParam;