rado 0.2.27 → 0.2.28

package/dist/define/Column.d.ts

@@ -1,8 +1,6 @@
 import { Callable } from '../util/Callable';
 import { EV, Expr, ExprData } from './Expr';
 import { Fields } from './Fields';
-declare const DATA: unique symbol;
-declare const TYPE: unique symbol;
 export declare enum ColumnType {
     String = "String",
     Integer = "Integer",
@@ -26,12 +24,12 @@ export interface ColumnData extends PartialColumnData {
     name: string;
 }
 export interface Column<T> {
-    [TYPE]: T;
-    [DATA]: PartialColumnData;
+    [Column.Type]: T;
+    [Column.Data]: PartialColumnData;
 }
 export declare namespace Column {
-    const Data: typeof DATA;
-    const Type: typeof TYPE;
+    const Data: unique symbol;
+    const Type: unique symbol;
     const IsOptional: unique symbol;
     const IsNullable: unique symbol;
     const IsPrimary: unique symbol;
@@ -41,8 +39,8 @@ interface ValueColumn<T> extends Expr<T> {
     <X extends T = T>(): ValueColumn<T extends null ? X | null : X>;
 }
 declare class ValueColumn<T> extends Callable implements Column<T> {
-    [TYPE]: T;
-    [DATA]: PartialColumnData;
+    [Column.Type]: T;
+    [Column.Data]: PartialColumnData;
     constructor(data: PartialColumnData);
     get nullable(): ValueColumn<T | null>;
     get unique(): ValueColumn<T>;
@@ -61,8 +59,8 @@ interface ObjectColumn<T> {
     <X extends T = T>(): Column<T extends null ? X | null : X> & Fields<X>;
 }
 declare class ObjectColumn<T> extends Callable implements Column<T> {
-    [TYPE]: T;
-    [DATA]: PartialColumnData;
+    [Column.Type]: T;
+    [Column.Data]: PartialColumnData;
     constructor(data: PartialColumnData);
     get nullable(): ObjectColumn<T | null>;
     get unique(): ObjectColumn<T>;
@@ -79,7 +77,7 @@ interface UnTyped {
     (name: string): UnTyped;
 }
 declare class UnTyped extends Callable {
-    [DATA]: PartialColumnData;
+    [Column.Data]: PartialColumnData;
     constructor(data?: PartialColumnData);
     get nullable(): NullableUnTyped;
     get unique(): UnTyped;
@@ -92,7 +90,7 @@ declare class UnTyped extends Callable {
     get array(): ValueColumn<any[]>;
 }
 declare class NullableUnTyped {
-    [DATA]: PartialColumnData;
+    [Column.Data]: PartialColumnData;
     get unique(): UnTyped;
     get string(): ValueColumn<string | null>;
     get integer(): ValueColumn<number | null>;

package/dist/define/Column.js

@@ -1,8 +1,6 @@
 // src/define/Column.ts
 import { Callable } from "../util/Callable.js";
 import { Expr, ExprData } from "./Expr.js";
-var DATA = Symbol("Column.Data");
-var TYPE = Symbol("Column.Type");
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
   ColumnType2["Integer"] = "Integer";
@@ -13,38 +11,38 @@ var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
 })(ColumnType || {});
 var Column;
 ((Column2) => {
-  Column2.Data = DATA;
-  Column2.Type = TYPE;
+  Column2.Data = Symbol("Column.Data");
+  Column2.Type = Symbol("Column.Type");
   function isColumn(input) {
-    return Boolean(input[DATA]);
+    return Boolean(input[Column2.Data]);
   }
   Column2.isColumn = isColumn;
 })(Column || (Column = {}));
 var ValueColumn = class extends Callable {
-  [DATA];
+  [Column.Data];
   constructor(data) {
     super(() => this);
-    this[DATA] = data;
+    this[Column.Data] = data;
   }
   get nullable() {
-    return new ValueColumn({ ...this[DATA], nullable: true });
+    return new ValueColumn({ ...this[Column.Data], nullable: true });
   }
   get unique() {
-    return new ValueColumn({ ...this[DATA], unique: true });
+    return new ValueColumn({ ...this[Column.Data], unique: true });
   }
   get autoIncrement() {
-    return new OptionalColumn({ ...this[DATA], autoIncrement: true });
+    return new OptionalColumn({ ...this[Column.Data], autoIncrement: true });
   }
   primaryKey(create) {
     return new PrimaryColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       primaryKey: true,
-      defaultValue: create ? () => ExprData.create(create()) : this[DATA].defaultValue
+      defaultValue: create ? () => ExprData.create(create()) : this[Column.Data].defaultValue
     });
   }
   references(column2) {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       references() {
         return ExprData.create(Expr.isExpr(column2) ? column2 : column2());
       }
@@ -52,7 +50,7 @@ var ValueColumn = class extends Callable {
   }
   default(value) {
     return new OptionalColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       defaultValue: createDefaultValue(value)
     });
   }
@@ -67,20 +65,20 @@ var PrimaryColumn = class extends ValueColumn {
   [Column.IsPrimary];
 };
 var ObjectColumn = class extends Callable {
-  [DATA];
+  [Column.Data];
   constructor(data) {
     super(() => this);
-    this[DATA] = data;
+    this[Column.Data] = data;
   }
   get nullable() {
-    return new ObjectColumn({ ...this[DATA], nullable: true });
+    return new ObjectColumn({ ...this[Column.Data], nullable: true });
   }
   get unique() {
-    return new ObjectColumn({ ...this[DATA], unique: true });
+    return new ObjectColumn({ ...this[Column.Data], unique: true });
   }
   defaultValue(value) {
     return new OptionalObjectColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       defaultValue: createDefaultValue(value)
     });
   }
@@ -89,58 +87,61 @@ var OptionalObjectColumn = class extends ObjectColumn {
   [Column.IsOptional];
 };
 var UnTyped = class extends Callable {
-  [DATA];
+  [Column.Data];
   constructor(data = {}) {
     super((name) => {
       return new ValueColumn({ ...data, name });
     });
-    this[DATA] = data;
+    this[Column.Data] = data;
   }
   get nullable() {
-    return new UnTyped({ ...this[DATA], nullable: true });
+    return new UnTyped({
+      ...this[Column.Data],
+      nullable: true
+    });
   }
   get unique() {
-    return new UnTyped({ ...this[DATA], unique: true });
+    return new UnTyped({ ...this[Column.Data], unique: true });
   }
   get string() {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "String" /* String */
     });
   }
   get integer() {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "Integer" /* Integer */
     });
   }
   get number() {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "Number" /* Number */
     });
   }
   get boolean() {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "Boolean" /* Boolean */
     });
   }
   get json() {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "Json" /* Json */
     });
   }
   get object() {
     return new ObjectColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "Json" /* Json */
     });
   }
   get array() {
     return new ValueColumn({
-      ...this[DATA],
+      ...this[Column.Data],
       type: "Json" /* Json */
     });
   }

package/dist/define/Expr.d.ts

@@ -5,9 +5,6 @@ import { QueryData } from './Query';
 import { Selection } from './Selection';
 import { Target } from './Target';
 import { SelectMultiple, SelectSingle } from './query/Select';
-declare const DATA: unique symbol;
-declare const TO_EXPR: unique symbol;
-declare const IS_EXPR: unique symbol;
 export declare enum UnOpType {
     Not = "Not",
     IsNull = "IsNull"
@@ -119,10 +116,12 @@ export declare namespace ExprData {
 }
 /** Expression or value of type T */
 export type EV<T> = Expr<T> | T;
+export interface Expr<T> {
+    [Expr.Data]: ExprData;
+    [Expr.IsExpr]: boolean;
+}
 export declare class Expr<T> {
     constructor(expr: ExprData);
-    [DATA]: ExprData;
-    [IS_EXPR]: boolean;
     asc(): OrderBy;
     desc(): OrderBy;
     not(): Expr<boolean>;
@@ -164,9 +163,9 @@ export declare class Expr<T> {
     get<T>(name: string): Expr<T>;
 }
 export declare namespace Expr {
-    const Data: typeof DATA;
-    const IsExpr: typeof IS_EXPR;
-    const ToExpr: typeof TO_EXPR;
+    const Data: unique symbol;
+    const IsExpr: unique symbol;
+    const ToExpr: unique symbol;
     const NULL: Expr<null>;
     function value<T>(value: T): Expr<T>;
     function create<T>(input: EV<T>): Expr<T>;
@@ -174,4 +173,3 @@ export declare namespace Expr {
     function or(...conditions: Array<EV<boolean>>): Expr<boolean>;
     function isExpr<T>(input: any): input is Expr<T>;
 }
-export {};

package/dist/define/Expr.js

@@ -4,9 +4,6 @@ import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";
 var { fromEntries, entries } = Object;
-var DATA = Symbol("Expr.Data");
-var TO_EXPR = Symbol("Expr.ToExpr");
-var IS_EXPR = Symbol("Expr.IsExpr");
 var UnOpType = /* @__PURE__ */ ((UnOpType2) => {
   UnOpType2["Not"] = "Not";
   UnOpType2["IsNull"] = "IsNull";
@@ -138,10 +135,10 @@ var ExprData;
   function create(input) {
     if (input === null || input === void 0)
       return new ExprData2.Param(new ParamData.Value(null));
-    if (input && (typeof input === "function" || typeof input === "object") && input[TO_EXPR])
-      input = input[TO_EXPR]();
+    if (input && (typeof input === "function" || typeof input === "object") && input[Expr.ToExpr])
+      input = input[Expr.ToExpr]();
     if (Expr.isExpr(input))
-      return input[DATA];
+      return input[Expr.Data];
     if (input && typeof input === "object" && !Array.isArray(input))
       return new ExprData2.Record(
         fromEntries(
@@ -154,18 +151,17 @@ var ExprData;
 })(ExprData || (ExprData = {}));
 var Expr = class {
   constructor(expr) {
-    this[DATA] = expr;
+    this[Expr.Data] = expr;
+    this[Expr.IsExpr] = true;
   }
-  [DATA];
-  [IS_EXPR] = true;
   asc() {
-    return { expr: this[DATA], order: OrderDirection.Asc };
+    return { expr: this[Expr.Data], order: OrderDirection.Asc };
   }
   desc() {
-    return { expr: this[DATA], order: OrderDirection.Desc };
+    return { expr: this[Expr.Data], order: OrderDirection.Desc };
   }
   not() {
-    return new Expr(new ExprData.UnOp("Not" /* Not */, this[DATA]));
+    return new Expr(new ExprData.UnOp("Not" /* Not */, this[Expr.Data]));
   }
   or(that) {
     const a = this;
@@ -174,7 +170,9 @@ var Expr = class {
       return b;
     if (a.isConstant(true) || b.isConstant(false))
       return this;
-    return new Expr(new ExprData.BinOp("Or" /* Or */, a[DATA], b[DATA]));
+    return new Expr(
+      new ExprData.BinOp("Or" /* Or */, a[Expr.Data], b[Expr.Data])
+    );
   }
   and(that) {
     const a = this;
@@ -183,19 +181,26 @@ var Expr = class {
       return this;
     if (a.isConstant(true) || b.isConstant(false))
       return b;
-    return new Expr(new ExprData.BinOp("And" /* And */, a[DATA], b[DATA]));
+    return new Expr(
+      new ExprData.BinOp("And" /* And */, a[Expr.Data], b[Expr.Data])
+    );
   }
   is(that) {
     if (that === null || Expr.isExpr(that) && that.isConstant(null))
       return this.isNull();
     return new Expr(
-      new ExprData.BinOp("Equals" /* Equals */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "Equals" /* Equals */,
+        this[Expr.Data],
+        ExprData.create(that)
+      )
     );
   }
   isConstant(value) {
-    switch (this[DATA].type) {
+    const expr = this[Expr.Data];
+    switch (expr.type) {
       case "ExprData.Param" /* Param */:
-        const param = this[DATA].param;
+        const param = expr.param;
         switch (param.type) {
           case ParamType.Value:
             return param.value === value;
@@ -210,101 +215,121 @@ var Expr = class {
     if (that === null || Expr.isExpr(that) && that.isConstant(null))
       return this.isNotNull();
     return new Expr(
-      new ExprData.BinOp("NotEquals" /* NotEquals */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "NotEquals" /* NotEquals */,
+        this[Expr.Data],
+        ExprData.create(that)
+      )
     );
   }
   isNull() {
-    return new Expr(new ExprData.UnOp("IsNull" /* IsNull */, this[DATA]));
+    return new Expr(new ExprData.UnOp("IsNull" /* IsNull */, this[Expr.Data]));
   }
   isNotNull() {
     return this.isNull().not();
   }
   isIn(that) {
     return new Expr(
-      new ExprData.BinOp("In" /* In */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("In" /* In */, this[Expr.Data], ExprData.create(that))
     );
   }
   isNotIn(that) {
     return new Expr(
-      new ExprData.BinOp("NotIn" /* NotIn */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "NotIn" /* NotIn */,
+        this[Expr.Data],
+        ExprData.create(that)
+      )
     );
   }
   isGreater(that) {
     return new Expr(
-      new ExprData.BinOp("Greater" /* Greater */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "Greater" /* Greater */,
+        this[Expr.Data],
+        ExprData.create(that)
+      )
     );
   }
   isGreaterOrEqual(that) {
     return new Expr(
       new ExprData.BinOp(
         "GreaterOrEqual" /* GreaterOrEqual */,
-        this[DATA],
+        this[Expr.Data],
         ExprData.create(that)
       )
     );
   }
   isLess(that) {
     return new Expr(
-      new ExprData.BinOp("Less" /* Less */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Less" /* Less */, this[Expr.Data], ExprData.create(that))
     );
   }
   isLessOrEqual(that) {
     return new Expr(
       new ExprData.BinOp(
         "LessOrEqual" /* LessOrEqual */,
-        this[DATA],
+        this[Expr.Data],
         ExprData.create(that)
       )
     );
   }
   add(that) {
     return new Expr(
-      new ExprData.BinOp("Add" /* Add */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Add" /* Add */, this[Expr.Data], ExprData.create(that))
     );
   }
   substract(that) {
     return new Expr(
-      new ExprData.BinOp("Subt" /* Subt */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Subt" /* Subt */, this[Expr.Data], ExprData.create(that))
     );
   }
   multiply(that) {
     return new Expr(
-      new ExprData.BinOp("Mult" /* Mult */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Mult" /* Mult */, this[Expr.Data], ExprData.create(that))
     );
   }
   remainder(that) {
     return new Expr(
-      new ExprData.BinOp("Mod" /* Mod */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Mod" /* Mod */, this[Expr.Data], ExprData.create(that))
     );
   }
   divide(that) {
     return new Expr(
-      new ExprData.BinOp("Div" /* Div */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Div" /* Div */, this[Expr.Data], ExprData.create(that))
     );
   }
   concat(that) {
     return new Expr(
-      new ExprData.BinOp("Concat" /* Concat */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "Concat" /* Concat */,
+        this[Expr.Data],
+        ExprData.create(that)
+      )
     );
   }
   like(that) {
     return new Expr(
-      new ExprData.BinOp("Like" /* Like */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Like" /* Like */, this[Expr.Data], ExprData.create(that))
     );
   }
   glob(that) {
     return new Expr(
-      new ExprData.BinOp("Glob" /* Glob */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp("Glob" /* Glob */, this[Expr.Data], ExprData.create(that))
     );
   }
   match(that) {
     return new Expr(
-      new ExprData.BinOp("Match" /* Match */, this[DATA], ExprData.create(that))
+      new ExprData.BinOp(
+        "Match" /* Match */,
+        this[Expr.Data],
+        ExprData.create(that)
+      )
     );
   }
   with(that) {
     return new Expr(
-      new ExprData.Merge(this[DATA], ExprData.create(that))
+      new ExprData.Merge(this[Expr.Data], ExprData.create(that))
     );
   }
   /**
@@ -338,7 +363,7 @@ var Expr = class {
   }
   filter(fn) {
     const alias = randomAlias();
-    const target = new Target.Expr(this[DATA], alias);
+    const target = new Target.Expr(this[Expr.Data], alias);
     return new Expr(
       new ExprData.Filter(
         target,
@@ -348,7 +373,7 @@ var Expr = class {
   }
   map(fn) {
     const alias = randomAlias();
-    const target = new Target.Expr(this[DATA], alias);
+    const target = new Target.Expr(this[Expr.Data], alias);
     return new Expr(
       new ExprData.Map(
         target,
@@ -360,13 +385,13 @@ var Expr = class {
     return this;
   }
   get(name) {
-    return new Expr(new ExprData.Field(this[DATA], name));
+    return new Expr(new ExprData.Field(this[Expr.Data], name));
   }
 };
 ((Expr2) => {
-  Expr2.Data = DATA;
-  Expr2.IsExpr = IS_EXPR;
-  Expr2.ToExpr = TO_EXPR;
+  Expr2.Data = Symbol("Expr.Data");
+  Expr2.IsExpr = Symbol("Expr.IsExpr");
+  Expr2.ToExpr = Symbol("Expr.ToExpr");
   Expr2.NULL = create(null);
   function value(value2) {
     return new Expr2(new ExprData.Param(new ParamData.Value(value2)));
@@ -387,7 +412,7 @@ var Expr = class {
   }
   Expr2.or = or;
   function isExpr(input) {
-    return input !== null && (typeof input === "object" || typeof input === "function") && input[IS_EXPR];
+    return input !== null && (typeof input === "object" || typeof input === "function") && input[Expr2.IsExpr];
   }
   Expr2.isExpr = isExpr;
 })(Expr || (Expr = {}));

package/dist/define/Query.d.ts

@@ -7,7 +7,6 @@ import { OrderBy } from './OrderBy';
 import { Selection } from './Selection';
 import { TableData } from './Table';
 import { Target } from './Target';
-declare const DATA: unique symbol;
 export declare enum QueryType {
     Insert = "QueryData.Insert",
     Select = "QueryData.Select",
@@ -135,19 +134,20 @@ export declare namespace QueryData {
     }
     export {};
 }
+export interface Query<T> {
+    [Query.Data]: QueryData;
+}
 export declare class Query<T> {
     [Selection.CursorType]: () => T;
-    [DATA]: QueryData;
     constructor(query: QueryData);
     next<T>(cursor: Query<T>): Query<T>;
     on(driver: Driver.Sync): T;
     on(driver: Driver.Async): Promise<T>;
     toSql(driver: Driver, options?: CompileOptions): string;
     toJSON(): QueryData;
-    protected addWhere(where: Array<EV<boolean>>): this[typeof DATA];
+    protected addWhere(where: Array<EV<boolean>>): this[typeof Query.Data];
 }
 export declare namespace Query {
-    const Data: typeof DATA;
+    const Data: unique symbol;
     function isQuery<T>(input: any): input is Query<T>;
 }
-export {};

package/dist/define/Query.js

@@ -1,7 +1,6 @@
 // src/define/Query.ts
 import { Expr } from "./Expr.js";
 var { assign } = Object;
-var DATA = Symbol("Query.Data");
 var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Insert"] = "QueryData.Insert";
   QueryType2["Select"] = "QueryData.Select";
@@ -100,30 +99,29 @@ var QueryData;
   QueryData2.Raw = Raw;
 })(QueryData || (QueryData = {}));
 var Query = class {
-  [DATA];
   constructor(query) {
-    this[DATA] = query;
+    this[Query.Data] = query;
   }
   next(cursor) {
     return new Query(
       new QueryData.Batch(
-        this[DATA].with({
-          queries: [this[DATA], cursor[DATA]]
+        this[Query.Data].with({
+          queries: [this[Query.Data], cursor[Query.Data]]
         })
       )
     );
   }
   on(driver) {
-    return driver.executeQuery(this[DATA]);
+    return driver.executeQuery(this[Query.Data]);
   }
   toSql(driver, options = { forceInline: true }) {
-    return driver.formatter.compile(this[DATA], options).sql;
+    return driver.formatter.compile(this[Query.Data], options).sql;
   }
   toJSON() {
-    return this[DATA];
+    return this[Query.Data];
   }
   addWhere(where) {
-    const query = this[DATA];
+    const query = this[Query.Data];
     const conditions = where.slice();
     if (query.where)
       conditions.push(new Expr(query.where));
@@ -131,9 +129,9 @@ var Query = class {
   }
 };
 ((Query2) => {
-  Query2.Data = DATA;
+  Query2.Data = Symbol("Query.Data");
   function isQuery(input) {
-    return input !== null && Boolean(DATA in input);
+    return input !== null && Boolean(Query2.Data in input);
   }
   Query2.isQuery = isQuery;
 })(Query || (Query = {}));

package/dist/define/Table.d.ts

@@ -5,8 +5,6 @@ import type { Fields } from './Fields';
 import { Index, IndexData } from './Index';
 import type { Selection } from './Selection';
 import { TableSelect } from './query/TableSelect';
-declare const DATA: unique symbol;
-declare const META: unique symbol;
 interface TableDefinition {
 }
 export declare class TableData {
@@ -27,12 +25,12 @@ export interface TableInstance<Definition> extends ClearFunctionProto {
 }
 export declare class TableInstance<Definition> {
     [Selection.TableType](): Table.Select<Definition>;
-    get [DATA](): TableData;
+    get [Table.Data](): TableData;
 }
 export type Table<Definition> = Definition & TableInstance<Definition>;
 export declare namespace Table {
-    export const Data: typeof DATA;
-    export const Meta: typeof META;
+    export const Data: unique symbol;
+    export const Meta: unique symbol;
     export type Of<Row> = Table<{
         [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & Fields<Row[K]>;
     }>;
@@ -60,6 +58,6 @@ export type table<T> = T extends Table<infer D> ? Table.Select<D> : never;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
 export declare function table<T extends {}>(define: Record<string, T | Define<T>>): Table<T>;
 export declare namespace table {
-    const meta: typeof META;
+    const meta: typeof Table.Meta;
 }
 export {};

package/dist/define/Table.js

@@ -16,8 +16,6 @@ var {
   setPrototypeOf,
   defineProperty
 } = Object;
-var DATA = Symbol("Table.Data");
-var META = Symbol("Table.Meta");
 var TableData = class {
   constructor(data) {
     assign(this, data);
@@ -25,8 +23,8 @@ var TableData = class {
 };
 var Table;
 ((Table2) => {
-  Table2.Data = DATA;
-  Table2.Meta = META;
+  Table2.Data = Symbol("Table.Data");
+  Table2.Meta = Symbol("Table.Meta");
 })(Table || (Table = {}));
 function createTable(data) {
   const target = new Target.Table(data);
@@ -63,7 +61,7 @@ function createTable(data) {
   delete call.length;
   for (const [key, value] of entries(expressions))
     defineProperty(call, key, { value, enumerable: true, configurable: true });
-  defineProperty(call, DATA, { value: data, enumerable: false });
+  defineProperty(call, Table.Data, { value: data, enumerable: false });
   defineProperty(call, Expr.ToExpr, { value: toExpr, enumerable: false });
   setPrototypeOf(call, getPrototypeOf(data.definition));
   return call;
@@ -117,7 +115,7 @@ function table(define) {
   return res;
 }
 ((table2) => {
-  table2.meta = META;
+  table2.meta = Table.Meta;
 })(table || (table = {}));
 export {
   Table,

package/dist/define/VirtualTable.d.ts

@@ -6,7 +6,6 @@ import { Selection } from './Selection';
 import { Table } from './Table';
 import { Target } from './Target';
 import { SelectMultiple } from './query/Select';
-declare const DATA: unique symbol;
 export interface VirtualTableInstance<Definition> extends ClearFunctionProto {
     (conditions: {
         [K in keyof Definition]?: Definition[K] extends Expr<infer V> ? EV<V> : never;
@@ -15,7 +14,7 @@ export interface VirtualTableInstance<Definition> extends ClearFunctionProto {
 }
 export declare class VirtualTableInstance<Definition> {
     [Selection.TableType](): Table.Select<Definition>;
-    get [DATA](): VirtualTableData;
+    get [VirtualTable.Data](): VirtualTableData;
 }
 export interface VirtualTableData {
     name: string;
@@ -24,10 +23,9 @@ export interface VirtualTableData {
 }
 export type VirtualTable<Definition> = Definition & VirtualTableInstance<Definition>;
 export declare namespace VirtualTable {
-    const Data: typeof DATA;
+    const Data: unique symbol;
     type Of<Row> = VirtualTable<{
         [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & Fields<Row[K]>;
     }>;
 }
 export declare function createVirtualTable<Definition>(data: VirtualTableData): VirtualTable<Definition>;
-export {};

package/dist/define/VirtualTable.js

@@ -1,10 +1,9 @@
 // src/define/VirtualTable.ts
 import { BinOpType, Expr, ExprData } from "./Expr.js";
 var { create, entries } = Object;
-var DATA = Symbol("VirtualTable.Data");
 var VirtualTable;
 ((VirtualTable2) => {
-  VirtualTable2.Data = DATA;
+  VirtualTable2.Data = Symbol("VirtualTable.Data");
 })(VirtualTable || (VirtualTable = {}));
 function createVirtualTable(data) {
   const cache = create(null);
@@ -23,7 +22,7 @@ function createVirtualTable(data) {
   }
   return new Proxy(call, {
     get(_, column) {
-      if (column === DATA)
+      if (column === VirtualTable.Data)
         return data;
       if (column === Expr.ToExpr)
         return new Expr(new ExprData.Row(data.target));

package/dist/sqlite/SqliteFunctions.d.ts

@@ -88,7 +88,7 @@ export type SqliteFunctions = {
     /** 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>;
+    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.
@@ -162,4 +162,4 @@ export declare const count: (x?: Expr<any>) => Expr<number>, iif: <T>(x: EV<bool
     (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: (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>, ...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: (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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",