@visactor/vquery 0.1.47 → 0.1.48

package/dist/dataset/convert/applyWhere.d.ts

@@ -0,0 +1,2 @@
+import { Where, WhereClause } from '../../types';
+export declare const applyWhere: <T>(where: Where<T> | WhereClause<T>) => string;

package/dist/dataset/convert/dslToSQL.d.ts

@@ -0,0 +1,2 @@
+import { QueryDSL } from '../../types';
+export declare const convertDSLToSQL: <T>(dsl: QueryDSL<T>, tableName: string) => string;

package/dist/dataset/convert/utils.d.ts

@@ -0,0 +1,6 @@
+import { Where, WhereClause, WhereGroup, WhereLeaf } from '../../types';
+import { SelectItem } from '../../types/QueryDSL/Select';
+export declare const isSelectItem: <T>(item: keyof T | SelectItem<T>) => item is SelectItem<T>;
+export declare const isWhereLeaf: <T>(where: Where<T> | WhereClause<T>) => where is WhereLeaf<T>;
+export declare const isWhereGroup: <T>(where: Where<T> | WhereClause<T>) => where is WhereGroup<T>;
+export declare const isStringOrNumber: (value: unknown) => value is string | number;

package/dist/dataset/dataset.d.ts

@@ -1,4 +1,4 @@
-import { DatasetColumn } from '../types';
+import { DatasetColumn, QueryDSL } from '../types';
 import { DuckDB } from '../db/duckDb';
 import { IndexedDB } from '../db/indexedDb';
 export declare class Dataset {
@@ -16,6 +16,16 @@ export declare class Dataset {
         dataset: any[];
         table: any;
     }>;
+    convertDSLToSQL<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): string;
+    query<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): Promise<{
+        performance: {
+            startAt: string;
+            endAt: string;
+            duration: number;
+        };
+        dataset: any[];
+        table: any;
+    }>;
     disconnect(): Promise<void>;
     get datasetId(): string;
 }

package/dist/index.cjs

@@ -33,6 +33,65 @@ __webpack_require__.d(__webpack_exports__, {
     isUrl: ()=>isUrl,
     VQuery: ()=>VQuery
 });
+const isSelectItem = (item)=>'object' == typeof item && 'field' in item;
+const isWhereLeaf = (where)=>'field' in where && 'op' in where && 'value' in where;
+const isWhereGroup = (where)=>'op' in where && 'conditions' in where;
+const isStringOrNumber = (value)=>'string' == typeof value || 'number' == typeof value;
+const applyWhere = (where)=>{
+    const escape = (str)=>{
+        if ('string' == typeof str) return `'${str.replace(/'/g, "''")}'`;
+        return str;
+    };
+    if (isWhereGroup(where)) {
+        const logicalOp = where.op.toUpperCase();
+        return `(${where.conditions.map((c)=>applyWhere(c)).join(` ${logicalOp} `)})`;
+    }
+    if (isWhereLeaf(where)) {
+        const { field, op, value } = where;
+        if ('is null' === op || 'is not null' === op) return `${field} ${op}`;
+        if ('in' === op || 'not in' === op) {
+            if (Array.isArray(value)) return `${field} ${op} (${value.map((v)=>escape(v)).join(', ')})`;
+        }
+        if ('between' === op || 'not between' === op) {
+            if (Array.isArray(value) && 2 === value.length && isStringOrNumber(value[0]) && isStringOrNumber(value[1])) {
+                const value0 = value[0];
+                const value1 = value[1];
+                return `${field} ${op} ${escape(value0)} and ${escape(value1)}`;
+            }
+        }
+        if (isStringOrNumber(value)) {
+            const value0 = value;
+            return `${field} ${op} ${escape(value0)}`;
+        }
+    }
+    return '';
+};
+const convertDSLToSQL = (dsl, tableName)=>{
+    let sql = 'SELECT';
+    if (dsl.select && dsl.select.length > 0) {
+        const selectFields = dsl.select.map((item)=>{
+            if ('string' == typeof item) return item;
+            if (isSelectItem(item)) {
+                if (item.func) return `${item.func}(${item.field})` + (item.alias ? ` AS "${item.alias}"` : '');
+                if (item.alias) return `${item.field} AS "${item.alias}"`;
+                return item.field;
+            }
+        });
+        sql += ` ${selectFields.join(', ')}`;
+    } else sql += ' *';
+    sql += ` FROM ${tableName}`;
+    if (dsl.where) {
+        const whereClause = applyWhere(dsl.where);
+        if (whereClause) sql += ` WHERE ${whereClause}`;
+    }
+    if (dsl.groupBy && dsl.groupBy.length > 0) sql += ` GROUP BY ${dsl.groupBy.join(', ')}`;
+    if (dsl.orderBy && dsl.orderBy.length > 0) {
+        const orderByFields = dsl.orderBy.map((item)=>`${item.field}${item.order ? ` ${item.order.toUpperCase()}` : ''}`);
+        sql += ` ORDER BY ${orderByFields.join(', ')}`;
+    }
+    if (dsl.limit) sql += ` LIMIT ${dsl.limit}`;
+    return sql;
+};
 class Dataset {
     duckDB;
     indexedDB;
@@ -82,6 +141,14 @@ class Dataset {
             }
         };
     }
+    convertDSLToSQL(queryDSL) {
+        return convertDSLToSQL(queryDSL, this.datasetId);
+    }
+    async query(queryDSL) {
+        const sql = this.convertDSLToSQL(queryDSL);
+        console.log(sql);
+        return this.queryBySQL(sql);
+    }
     async disconnect() {
         await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
     }

package/dist/index.js

@@ -1,4 +1,63 @@
 import { AsyncDuckDB, ConsoleLogger, selectBundle } from "@duckdb/duckdb-wasm";
+const isSelectItem = (item)=>'object' == typeof item && 'field' in item;
+const isWhereLeaf = (where)=>'field' in where && 'op' in where && 'value' in where;
+const isWhereGroup = (where)=>'op' in where && 'conditions' in where;
+const isStringOrNumber = (value)=>'string' == typeof value || 'number' == typeof value;
+const applyWhere = (where)=>{
+    const escape = (str)=>{
+        if ('string' == typeof str) return `'${str.replace(/'/g, "''")}'`;
+        return str;
+    };
+    if (isWhereGroup(where)) {
+        const logicalOp = where.op.toUpperCase();
+        return `(${where.conditions.map((c)=>applyWhere(c)).join(` ${logicalOp} `)})`;
+    }
+    if (isWhereLeaf(where)) {
+        const { field, op, value } = where;
+        if ('is null' === op || 'is not null' === op) return `${field} ${op}`;
+        if ('in' === op || 'not in' === op) {
+            if (Array.isArray(value)) return `${field} ${op} (${value.map((v)=>escape(v)).join(', ')})`;
+        }
+        if ('between' === op || 'not between' === op) {
+            if (Array.isArray(value) && 2 === value.length && isStringOrNumber(value[0]) && isStringOrNumber(value[1])) {
+                const value0 = value[0];
+                const value1 = value[1];
+                return `${field} ${op} ${escape(value0)} and ${escape(value1)}`;
+            }
+        }
+        if (isStringOrNumber(value)) {
+            const value0 = value;
+            return `${field} ${op} ${escape(value0)}`;
+        }
+    }
+    return '';
+};
+const convertDSLToSQL = (dsl, tableName)=>{
+    let sql = 'SELECT';
+    if (dsl.select && dsl.select.length > 0) {
+        const selectFields = dsl.select.map((item)=>{
+            if ('string' == typeof item) return item;
+            if (isSelectItem(item)) {
+                if (item.func) return `${item.func}(${item.field})` + (item.alias ? ` AS "${item.alias}"` : '');
+                if (item.alias) return `${item.field} AS "${item.alias}"`;
+                return item.field;
+            }
+        });
+        sql += ` ${selectFields.join(', ')}`;
+    } else sql += ' *';
+    sql += ` FROM ${tableName}`;
+    if (dsl.where) {
+        const whereClause = applyWhere(dsl.where);
+        if (whereClause) sql += ` WHERE ${whereClause}`;
+    }
+    if (dsl.groupBy && dsl.groupBy.length > 0) sql += ` GROUP BY ${dsl.groupBy.join(', ')}`;
+    if (dsl.orderBy && dsl.orderBy.length > 0) {
+        const orderByFields = dsl.orderBy.map((item)=>`${item.field}${item.order ? ` ${item.order.toUpperCase()}` : ''}`);
+        sql += ` ORDER BY ${orderByFields.join(', ')}`;
+    }
+    if (dsl.limit) sql += ` LIMIT ${dsl.limit}`;
+    return sql;
+};
 class Dataset {
     duckDB;
     indexedDB;
@@ -48,6 +107,14 @@ class Dataset {
             }
         };
     }
+    convertDSLToSQL(queryDSL) {
+        return convertDSLToSQL(queryDSL, this.datasetId);
+    }
+    async query(queryDSL) {
+        const sql = this.convertDSLToSQL(queryDSL);
+        console.log(sql);
+        return this.queryBySQL(sql);
+    }
     async disconnect() {
         await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
     }

package/dist/types/QueryDSL/GroupBy.d.ts

@@ -0,0 +1 @@
+export type GroupBy<T> = Array<keyof T>;

package/dist/types/QueryDSL/OrderBy.d.ts

@@ -0,0 +1,4 @@
+export type OrderBy<T> = Array<{
+    field: keyof T;
+    order?: 'asc' | 'desc';
+}>;

package/dist/types/QueryDSL/QueryDSL.d.ts

@@ -0,0 +1,11 @@
+import { GroupBy } from './GroupBy';
+import { OrderBy } from './OrderBy';
+import { Select } from './Select';
+import { Where } from './Where';
+export interface QueryDSL<Table> {
+    select: Select<Table>;
+    where?: Where<Table>;
+    groupBy?: GroupBy<Table>;
+    orderBy?: OrderBy<Table>;
+    limit?: number;
+}

package/dist/types/QueryDSL/Select.d.ts

@@ -0,0 +1,7 @@
+export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export type SelectItem<T> = {
+    field: keyof T;
+    alias?: string;
+    func?: AggregateFunction;
+};
+export type Select<T> = Array<keyof T | SelectItem<T>>;

package/dist/types/QueryDSL/Where.d.ts

@@ -0,0 +1,24 @@
+export type Where<T> = WhereGroup<T>;
+export type WhereGroup<T> = {
+    op: 'and' | 'or';
+    conditions: Array<WhereClause<T>>;
+};
+export type WhereClause<T> = WhereLeaf<T> | WhereGroup<T>;
+export type WhereLeaf<T> = {
+    [K in keyof T]: {
+        [O in Operator]: {
+            field: K;
+            op: O;
+        } & (O extends 'is null' | 'is not null' ? {
+            value?: never;
+        } : O extends 'in' | 'not in' ? {
+            value: T[K][];
+        } : O extends 'between' | 'not between' ? {
+            value: [T[K], T[K]];
+        } : {
+            value: T[K];
+        });
+    }[Operator];
+}[keyof T];
+type Operator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'like' | 'not like' | 'ilike' | 'not ilike' | 'in' | 'not in' | 'between' | 'not between' | 'is null' | 'is not null';
+export {};

package/dist/types/QueryDSL/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/QueryDSL/index.d.ts

@@ -0,0 +1,5 @@
+export type { QueryDSL } from './QueryDSL';
+export type { GroupBy } from './GroupBy';
+export type { OrderBy } from './OrderBy';
+export type { Select } from './Select';
+export type { Where, WhereClause, WhereLeaf, WhereGroup } from './Where';

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './DataSet';
 export * from './DataSource';
 export * from './QueryResult';
+export * from './QueryDSL';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vquery",
-  "version": "0.1.47",
+  "version": "0.1.48",
   "type": "module",
   "exports": {
     ".": {
@@ -15,7 +15,7 @@
     "dist"
   ],
   "dependencies": {
-    "@duckdb/duckdb-wasm": "latest"
+    "@duckdb/duckdb-wasm": "1.30.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.35.0",