@visactor/vquery 0.1.46 → 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

@@ -0,0 +1,31 @@
+import { DatasetColumn, QueryDSL } from '../types';
+import { DuckDB } from '../db/duckDb';
+import { IndexedDB } from '../db/indexedDb';
+export declare class Dataset {
+    private duckDB;
+    private indexedDB;
+    private _datasetId;
+    constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
+    init(temporaryStructs?: DatasetColumn[]): Promise<void>;
+    queryBySQL(sql: string): Promise<{
+        performance: {
+            startAt: string;
+            endAt: string;
+            duration: number;
+        };
+        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/dataset/index.d.ts

@@ -0,0 +1 @@
+export { Dataset } from './dataset';

package/dist/index.cjs

@@ -33,14 +33,100 @@ __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;
     _datasetId;
-    _tableName;
-    constructor(duckDB, datasetId, tableName){
+    constructor(duckDB, indexedDB1, datasetId){
         this.duckDB = duckDB;
+        this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
-        this._tableName = tableName;
+    }
+    async init(temporaryStructs) {
+        const readFunctionMap = {
+            csv: 'read_csv_auto',
+            json: 'read_json_auto',
+            xlsx: 'read_excel',
+            parquet: 'read_parquet'
+        };
+        const dataTypeMap = {
+            number: 'DOUBLE',
+            string: 'VARCHAR',
+            date: 'DATE',
+            datetime: 'TIMESTAMP',
+            timestamp: 'TIMESTAMP'
+        };
+        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
+        const { dataSource } = datasetInfo;
+        const datasetSchema = datasetInfo.datasetSchema;
+        const columns = temporaryStructs || datasetSchema.columns;
+        const readFunction = readFunctionMap[dataSource.type];
+        if (!readFunction) throw new Error(`Unsupported dataSource type: ${dataSource.type}`);
+        await this.duckDB.writeFile(this._datasetId, dataSource.blob);
+        const columnsStruct = `{${columns.map((c)=>`'${c.name}': '${dataTypeMap[c.type] || 'VARCHAR'}'`).join(', ')}}`;
+        const columnNames = columns.map((c)=>`"${c.name}"`).join(', ');
+        const createViewSql = `CREATE OR REPLACE VIEW "${this._datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${this._datasetId}', columns=${columnsStruct})`;
+        await this.duckDB.query(createViewSql);
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
@@ -55,13 +141,20 @@ class Dataset {
             }
         };
     }
-    async disConnect() {}
+    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}"`);
+    }
     get datasetId() {
         return this._datasetId;
     }
-    get tableName() {
-        return this._tableName;
-    }
 }
 const duckdb_wasm_namespaceObject = require("@duckdb/duckdb-wasm");
 class DuckDB {
@@ -312,22 +405,6 @@ class DataSourceBuilder {
         return await response.blob();
     }
 }
-function mapDataTypeToDuckDB(type) {
-    switch(type){
-        case 'number':
-            return 'DOUBLE';
-        case 'string':
-            return 'VARCHAR';
-        case 'date':
-            return 'DATE';
-        case 'datetime':
-            return 'TIMESTAMP';
-        case 'timestamp':
-            return 'TIMESTAMP';
-        default:
-            return 'VARCHAR';
-    }
-}
 class VQuery {
     duckDB;
     indexedDB;
@@ -363,23 +440,19 @@ class VQuery {
     }
     async connectDataset(datasetId) {
         await this.ensureInitialized();
-        const datasetInfo = await this.indexedDB.readDataset(datasetId);
-        if (!datasetInfo) throw new Error(`Dataset ${datasetId} not found`);
-        const { dataSource, datasetSchema } = datasetInfo;
-        const readFunctionMap = {
-            csv: 'read_csv_auto',
-            json: 'read_json_auto',
-            xlsx: 'read_excel',
-            parquet: 'read_parquet'
-        };
-        const readFunction = readFunctionMap[dataSource.type];
-        if (!readFunction) throw new Error(`Unsupported dataSource type: ${dataSource.type}`);
-        await this.duckDB.writeFile(datasetId, dataSource.blob);
-        const columnsStruct = `{${datasetSchema.columns.map((c)=>`'${c.name}': '${mapDataTypeToDuckDB(c.type)}'`).join(', ')}}`;
-        const columnNames = datasetSchema.columns.map((c)=>`"${c.name}"`).join(', ');
-        const createViewSql = `CREATE OR REPLACE VIEW "${datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${datasetId}', columns=${columnsStruct})`;
-        await this.duckDB.query(createViewSql);
-        return new Dataset(this.duckDB, datasetId, datasetSchema.datasetAlias || datasetId);
+        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        await dataset.init();
+        return dataset;
+    }
+    async connectTemporaryDataset(datasetId, temporaryDatasetSchema) {
+        await this.ensureInitialized();
+        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        await dataset.init(temporaryDatasetSchema);
+        return dataset;
+    }
+    async close() {
+        await this.ensureInitialized();
+        await this.duckDB.close();
     }
 }
 exports.DataSourceBuilder = __webpack_exports__.DataSourceBuilder;

package/dist/index.js

@@ -1,12 +1,98 @@
 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;
     _datasetId;
-    _tableName;
-    constructor(duckDB, datasetId, tableName){
+    constructor(duckDB, indexedDB1, datasetId){
         this.duckDB = duckDB;
+        this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
-        this._tableName = tableName;
+    }
+    async init(temporaryStructs) {
+        const readFunctionMap = {
+            csv: 'read_csv_auto',
+            json: 'read_json_auto',
+            xlsx: 'read_excel',
+            parquet: 'read_parquet'
+        };
+        const dataTypeMap = {
+            number: 'DOUBLE',
+            string: 'VARCHAR',
+            date: 'DATE',
+            datetime: 'TIMESTAMP',
+            timestamp: 'TIMESTAMP'
+        };
+        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
+        const { dataSource } = datasetInfo;
+        const datasetSchema = datasetInfo.datasetSchema;
+        const columns = temporaryStructs || datasetSchema.columns;
+        const readFunction = readFunctionMap[dataSource.type];
+        if (!readFunction) throw new Error(`Unsupported dataSource type: ${dataSource.type}`);
+        await this.duckDB.writeFile(this._datasetId, dataSource.blob);
+        const columnsStruct = `{${columns.map((c)=>`'${c.name}': '${dataTypeMap[c.type] || 'VARCHAR'}'`).join(', ')}}`;
+        const columnNames = columns.map((c)=>`"${c.name}"`).join(', ');
+        const createViewSql = `CREATE OR REPLACE VIEW "${this._datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${this._datasetId}', columns=${columnsStruct})`;
+        await this.duckDB.query(createViewSql);
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
@@ -21,13 +107,20 @@ class Dataset {
             }
         };
     }
-    async disConnect() {}
+    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}"`);
+    }
     get datasetId() {
         return this._datasetId;
     }
-    get tableName() {
-        return this._tableName;
-    }
 }
 class DuckDB {
     db = null;
@@ -277,22 +370,6 @@ class DataSourceBuilder {
         return await response.blob();
     }
 }
-function mapDataTypeToDuckDB(type) {
-    switch(type){
-        case 'number':
-            return 'DOUBLE';
-        case 'string':
-            return 'VARCHAR';
-        case 'date':
-            return 'DATE';
-        case 'datetime':
-            return 'TIMESTAMP';
-        case 'timestamp':
-            return 'TIMESTAMP';
-        default:
-            return 'VARCHAR';
-    }
-}
 class VQuery {
     duckDB;
     indexedDB;
@@ -328,23 +405,19 @@ class VQuery {
     }
     async connectDataset(datasetId) {
         await this.ensureInitialized();
-        const datasetInfo = await this.indexedDB.readDataset(datasetId);
-        if (!datasetInfo) throw new Error(`Dataset ${datasetId} not found`);
-        const { dataSource, datasetSchema } = datasetInfo;
-        const readFunctionMap = {
-            csv: 'read_csv_auto',
-            json: 'read_json_auto',
-            xlsx: 'read_excel',
-            parquet: 'read_parquet'
-        };
-        const readFunction = readFunctionMap[dataSource.type];
-        if (!readFunction) throw new Error(`Unsupported dataSource type: ${dataSource.type}`);
-        await this.duckDB.writeFile(datasetId, dataSource.blob);
-        const columnsStruct = `{${datasetSchema.columns.map((c)=>`'${c.name}': '${mapDataTypeToDuckDB(c.type)}'`).join(', ')}}`;
-        const columnNames = datasetSchema.columns.map((c)=>`"${c.name}"`).join(', ');
-        const createViewSql = `CREATE OR REPLACE VIEW "${datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${datasetId}', columns=${columnsStruct})`;
-        await this.duckDB.query(createViewSql);
-        return new Dataset(this.duckDB, datasetId, datasetSchema.datasetAlias || datasetId);
+        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        await dataset.init();
+        return dataset;
+    }
+    async connectTemporaryDataset(datasetId, temporaryDatasetSchema) {
+        await this.ensureInitialized();
+        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        await dataset.init(temporaryDatasetSchema);
+        return dataset;
+    }
+    async close() {
+        await this.ensureInitialized();
+        await this.duckDB.close();
     }
 }
 export { DataSourceBuilder, VQuery, isBase64Url, isHttpUrl, isUrl };

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/dist/vquery.d.ts

@@ -1,5 +1,5 @@
-import { Dataset } from './dataset';
-import { DatasetSchema, TidyDatum, DataSourceType } from './types';
+import { Dataset } from './dataset/dataset';
+import { DatasetSchema, TidyDatum, DataSourceType, DatasetColumn } from './types';
 export declare class VQuery {
     private duckDB;
     private indexedDB;
@@ -30,4 +30,14 @@ export declare class VQuery {
      * 连接数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
      */
     connectDataset(datasetId: string): Promise<Dataset>;
+    /**
+     * 连接临时数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
+     * @param datasetId
+     * @returns
+     */
+    connectTemporaryDataset(datasetId: string, temporaryDatasetSchema?: DatasetColumn[]): Promise<Dataset>;
+    /**
+     * 关闭所有数据集连接，释放DuckDB资源
+     */
+    close(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vquery",
-  "version": "0.1.46",
+  "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",

package/dist/dataset.d.ts

@@ -1,19 +0,0 @@
-import { DuckDB } from './db/duckDb';
-export declare class Dataset {
-    private duckDB;
-    private _datasetId;
-    private _tableName;
-    constructor(duckDB: DuckDB, datasetId: string, tableName: string);
-    queryBySQL(sql: string): Promise<{
-        performance: {
-            startAt: string;
-            endAt: string;
-            duration: number;
-        };
-        dataset: any[];
-        table: any;
-    }>;
-    disConnect(): Promise<void>;
-    get datasetId(): string;
-    get tableName(): string;
-}