@visactor/vquery 0.1.48 → 0.1.50

package/dist/data-source-builder/dataSourceBuilder.d.ts

@@ -0,0 +1,16 @@
+import { DatasetSourceType, RawDatasetSource } from '../types';
+export declare class DatasetSourceBuilder {
+    private type;
+    private value;
+    constructor(raw: RawDatasetSource);
+    static from(raw: RawDatasetSource): DatasetSourceBuilder;
+    build(): Promise<{
+        type: DatasetSourceType;
+        blob: Blob;
+    }>;
+    /**
+     * 将不同类型的数据转换为Blob
+     */
+    private static convertToBlob;
+    private static fetchBlob;
+}

package/dist/data-source-builder/index.d.ts

@@ -0,0 +1 @@
+export { DatasetSourceBuilder } from './dataSourceBuilder';

package/dist/dataset/dataset.d.ts

@@ -6,8 +6,9 @@ export declare class Dataset {
     private indexedDB;
     private _datasetId;
     constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
-    init(temporaryStructs?: DatasetColumn[]): Promise<void>;
-    queryBySQL(sql: string): Promise<{
+    init(temporaryColumns?: DatasetColumn[]): Promise<void>;
+    createOrReplaceView(columns?: DatasetColumn[]): Promise<void>;
+    query<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): Promise<{
         performance: {
             startAt: string;
             endAt: string;
@@ -16,8 +17,7 @@ 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<{
+    queryBySQL(sql: string): Promise<{
         performance: {
             startAt: string;
             endAt: string;

package/dist/dataset/index.d.ts

@@ -1 +1,2 @@
 export { Dataset } from './dataset';
+export { convertDSLToSQL } from '../sql-builder';

package/dist/db/indexedDb.d.ts

@@ -1,4 +1,4 @@
-import { DataSource } from '../types';
+import { DatasetSource } from '../types';
 import { DatasetSchema } from '../types/DataSet';
 export declare class IndexedDB {
     private db;
@@ -7,15 +7,15 @@ export declare class IndexedDB {
     constructor(dbName: string);
     open: () => Promise<void>;
     close: () => void;
-    writeDataset: (datasetId: string, dataSource: DataSource, datasetSchema: DatasetSchema) => Promise<void>;
+    writeDataset: (datasetId: string, datasetSchema: DatasetSchema, datasetSource?: DatasetSource) => Promise<void>;
     readDataset: (datasetId: string) => Promise<{
-        dataSource: DataSource;
+        datasetSource?: DatasetSource;
         datasetSchema: DatasetSchema;
     } | null>;
     deleteDataset: (datasetId: string) => Promise<void>;
     listDatasets: () => Promise<{
         datasetId: string;
-        dataSource: DataSource;
+        dataSource?: DatasetSource;
         datasetSchema: DatasetSchema;
     }[]>;
 }

package/dist/index.cjs

@@ -27,70 +27,154 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    DataSourceBuilder: ()=>DataSourceBuilder,
+    DatasetSourceBuilder: ()=>DatasetSourceBuilder,
     isHttpUrl: ()=>isHttpUrl,
+    convertDSLToSQL: ()=>convertDSLToSQL,
     isBase64Url: ()=>isBase64Url,
     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} `)})`;
+const external_kysely_namespaceObject = require("kysely");
+class PostgresDialect {
+    createDriver() {
+        return new external_kysely_namespaceObject.DummyDriver();
     }
-    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)}`;
+    createQueryCompiler() {
+        return new external_kysely_namespaceObject.PostgresQueryCompiler();
+    }
+    createAdapter() {
+        return new external_kysely_namespaceObject.PostgresAdapter();
+    }
+    createIntrospector(db) {
+        class NullIntrospector {
+            async getSchemas() {
+                return [];
             }
+            async getTables(options) {
+                options?.withInternalKyselyTables;
+                return [];
+            }
+            async getMetadata(options) {
+                options?.withInternalKyselyTables;
+                return {
+                    tables: []
+                };
+            }
+        }
+        return new NullIntrospector();
+    }
+}
+const isSelectItem = (item)=>'object' == typeof item && 'field' in item;
+const escapeValue = (value)=>{
+    if (null === value) return 'null';
+    if ('string' == typeof value) return `'${value.replace(/'/g, "''")}'`;
+    if ('number' == typeof value) return `${value}`;
+    if ('boolean' == typeof value) return value ? 'TRUE' : 'FALSE';
+    return `'${String(value).replace(/'/g, "''")}'`;
+};
+const inlineParameters = (sql, params)=>{
+    if (0 === params.length) return sql;
+    if (sql.includes('?')) {
+        let out = sql;
+        for (const p of params)out = out.replace(/\?/, escapeValue(p));
+        return out;
+    }
+    if (/\$\d+/.test(sql)) return sql.replace(/\$(\d+)/g, (_, idx)=>{
+        const i = Number(idx) - 1;
+        const v = params[i];
+        return escapeValue(v);
+    });
+    return sql;
+};
+const applyWhere = (where)=>{
+    const toRaw = (w)=>{
+        if ('op' in w && 'conditions' in w) {
+            const parts = w.conditions.map((c)=>toRaw(c));
+            const sep = (0, external_kysely_namespaceObject.sql)` ${external_kysely_namespaceObject.sql.raw(w.op)} `;
+            return (0, external_kysely_namespaceObject.sql)`(${external_kysely_namespaceObject.sql.join(parts, sep)})`;
         }
-        if (isStringOrNumber(value)) {
-            const value0 = value;
-            return `${field} ${op} ${escape(value0)}`;
+        const leaf = w;
+        const field = leaf.field;
+        const value = leaf.value;
+        switch(leaf.op){
+            case 'is null':
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} is null`;
+            case 'is not null':
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} is not null`;
+            case 'in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} in (${external_kysely_namespaceObject.sql.join(items.map((v)=>external_kysely_namespaceObject.sql.val(v)))})`;
+                }
+            case 'not in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return (0, external_kysely_namespaceObject.sql)`not ${external_kysely_namespaceObject.sql.ref(field)} in (${external_kysely_namespaceObject.sql.join(items.map((v)=>external_kysely_namespaceObject.sql.val(v)))})`;
+                }
+            case 'between':
+                {
+                    const [a, b] = value;
+                    return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} between (${external_kysely_namespaceObject.sql.val(a)}, ${external_kysely_namespaceObject.sql.val(b)})`;
+                }
+            case 'not between':
+                {
+                    const [a, b] = value;
+                    return (0, external_kysely_namespaceObject.sql)`not ${external_kysely_namespaceObject.sql.ref(field)} between (${external_kysely_namespaceObject.sql.val(a)}, ${external_kysely_namespaceObject.sql.val(b)})`;
+                }
+            default:
+                return (0, external_kysely_namespaceObject.sql)`${external_kysely_namespaceObject.sql.ref(field)} ${external_kysely_namespaceObject.sql.raw(leaf.op)} ${external_kysely_namespaceObject.sql.val(value)}`;
         }
+    };
+    return toRaw(where);
+};
+const applyGroupBy = (qb, fields)=>{
+    if (fields && fields.length > 0) {
+        const exprs = fields.map((f)=>external_kysely_namespaceObject.sql.id(f));
+        qb = qb.groupBy(exprs);
     }
-    return '';
+    return qb;
+};
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
 };
 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;
+    const db = new external_kysely_namespaceObject.Kysely({
+        dialect: new PostgresDialect()
+    });
+    let qb = db.selectFrom(tableName);
+    qb = dsl.select && dsl.select.length > 0 ? qb.select((eb)=>dsl.select.map((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;
+                const field = item.field;
+                if (item.func) {
+                    const alias = item.alias ?? field;
+                    switch(item.func){
+                        case 'avg':
+                            return eb.fn.avg(field).as(alias);
+                        case 'sum':
+                            return eb.fn.sum(field).as(alias);
+                        case 'min':
+                            return eb.fn.min(field).as(alias);
+                        case 'max':
+                            return eb.fn.max(field).as(alias);
+                        case 'count':
+                            return eb.fn.count(field).as(alias);
+                    }
+                }
+                return item.alias ? eb.ref(field).as(item.alias) : 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;
+            return item;
+        })) : qb.selectAll();
+    if (dsl.where) qb = qb.where(applyWhere(dsl.where));
+    qb = applyGroupBy(qb, dsl.groupBy);
+    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy)qb = qb.orderBy(o.field, o.order ?? 'asc');
+    qb = applyLimit(qb, dsl.limit);
+    const compiled = qb.compile();
+    return inlineParameters(compiled.sql, compiled.parameters);
 };
 class Dataset {
     duckDB;
@@ -101,7 +185,13 @@ class Dataset {
         this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
     }
-    async init(temporaryStructs) {
+    async init(temporaryColumns = []) {
+        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
+        const columns = temporaryColumns.length > 0 ? temporaryColumns : datasetInfo.datasetSchema.columns;
+        if (columns.length > 0) await this.createOrReplaceView(columns);
+    }
+    async createOrReplaceView(columns = []) {
         const readFunctionMap = {
             csv: 'read_csv_auto',
             json: 'read_json_auto',
@@ -117,16 +207,20 @@ class Dataset {
         };
         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);
+        const { datasetSource: dataSource } = datasetInfo;
+        if (dataSource) {
+            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 query(queryDSL) {
+        const sql = convertDSLToSQL(queryDSL, this.datasetId);
+        return this.queryBySQL(sql);
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
@@ -141,14 +235,6 @@ 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}"`);
     }
@@ -248,7 +334,7 @@ class IndexedDB {
             this.db = null;
         }
     };
-    writeDataset = (datasetId, dataSource, datasetSchema)=>new Promise((resolve, reject)=>{
+    writeDataset = (datasetId, datasetSchema, datasetSource)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
                 this.datasetStoreName
@@ -256,8 +342,8 @@ class IndexedDB {
             const store = transaction.objectStore(this.datasetStoreName);
             const request = store.put({
                 datasetId,
-                dataSource,
-                datasetSchema
+                datasetSchema,
+                datasetSource
             });
             request.onsuccess = ()=>{
                 resolve();
@@ -314,18 +400,18 @@ class IndexedDB {
 const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
 const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
 const isBase64Url = (url)=>url.startsWith('data:');
-class DataSourceBuilder {
+class DatasetSourceBuilder {
     type;
     value;
-    constructor(type, value){
-        this.type = type;
-        this.value = value;
+    constructor(raw){
+        this.type = raw.type;
+        this.value = raw.rawDataset;
     }
-    static from(type, value) {
-        return new DataSourceBuilder(type, value);
+    static from(raw) {
+        return new DatasetSourceBuilder(raw);
     }
     async build() {
-        const blob = await DataSourceBuilder.convertToBlob(this.type, this.value);
+        const blob = await DatasetSourceBuilder.convertToBlob(this.type, this.value);
         return {
             type: this.type,
             blob: blob
@@ -339,7 +425,7 @@ class DataSourceBuilder {
             ], {
                 type: 'text/csv'
             });
-            if ('string' == typeof csvSource && isUrl(csvSource)) return DataSourceBuilder.fetchBlob(csvSource);
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DatasetSourceBuilder.fetchBlob(csvSource);
             return new Blob([
                 JSON.stringify(csvSource)
             ], {
@@ -352,7 +438,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/json'
             });
-            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DataSourceBuilder.fetchBlob(jsonSource);
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DatasetSourceBuilder.fetchBlob(jsonSource);
             return new Blob([
                 JSON.stringify(jsonSource)
             ], {
@@ -365,7 +451,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/parquet'
             });
-            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DataSourceBuilder.fetchBlob(parquetSource);
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DatasetSourceBuilder.fetchBlob(parquetSource);
             return new Blob([
                 parquetSource
             ], {
@@ -378,7 +464,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
             });
-            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DataSourceBuilder.fetchBlob(xlsxSource);
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DatasetSourceBuilder.fetchBlob(xlsxSource);
             return new Blob([
                 xlsxSource
             ], {
@@ -413,56 +499,74 @@ class VQuery {
         this.duckDB = new DuckDB();
         this.indexedDB = new IndexedDB(dbName);
     }
-    async ensureInitialized() {
+    async checkInitialized() {
         if (!this.isInitialized) {
             await this.duckDB.init();
             await this.indexedDB.open();
             this.isInitialized = true;
         }
     }
-    async createDataset(datasetId, data, type, datasetSchema) {
-        await this.ensureInitialized();
-        const dataSource = await DataSourceBuilder.from(type, data).build();
-        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+    async checkDatasetExists(datasetId) {
+        if (!await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} not exists, please create it first`);
     }
-    async updateDataset(datasetId, data, type, datasetSchema) {
-        await this.ensureInitialized();
-        const dataSource = await DataSourceBuilder.from(type, data).build();
-        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+    async createDataset(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        if (await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} already exists`);
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
-    async deleteDataset(datasetId) {
-        await this.ensureInitialized();
-        await this.indexedDB.deleteDataset(datasetId);
+    async updateDatasetSource(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
-    async listDatasets() {
-        await this.ensureInitialized();
-        return this.indexedDB.listDatasets();
+    async dropDataset(datasetId) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        await this.indexedDB.deleteDataset(datasetId);
     }
-    async connectDataset(datasetId) {
-        await this.ensureInitialized();
+    async connectDataset(datasetId, temporaryColumns = []) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
         const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init();
+        await dataset.init(temporaryColumns);
         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 hasDataset(datasetId) {
+        await this.checkInitialized();
+        const datasets = await this.indexedDB.listDatasets();
+        return datasets.some((item)=>item.datasetId === datasetId);
+    }
+    async listDatasets() {
+        await this.checkInitialized();
+        return this.indexedDB.listDatasets();
     }
     async close() {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         await this.duckDB.close();
     }
 }
-exports.DataSourceBuilder = __webpack_exports__.DataSourceBuilder;
+exports.DatasetSourceBuilder = __webpack_exports__.DatasetSourceBuilder;
 exports.VQuery = __webpack_exports__.VQuery;
+exports.convertDSLToSQL = __webpack_exports__.convertDSLToSQL;
 exports.isBase64Url = __webpack_exports__.isBase64Url;
 exports.isHttpUrl = __webpack_exports__.isHttpUrl;
 exports.isUrl = __webpack_exports__.isUrl;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "DataSourceBuilder",
+    "DatasetSourceBuilder",
     "VQuery",
+    "convertDSLToSQL",
     "isBase64Url",
     "isHttpUrl",
     "isUrl"

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { VQuery } from './vquery';
-export { DataSourceBuilder } from './dataSourceBuilder/dataSourceBuilder';
+export { convertDSLToSQL } from './dataset';
+export { DatasetSourceBuilder } from './data-source-builder/dataSourceBuilder';
 export * from './utils';

package/dist/index.js

@@ -1,62 +1,145 @@
+import { DummyDriver, Kysely, PostgresAdapter, PostgresQueryCompiler, sql as external_kysely_sql } from "kysely";
 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} `)})`;
+class PostgresDialect {
+    createDriver() {
+        return new DummyDriver();
     }
-    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)}`;
+    createQueryCompiler() {
+        return new PostgresQueryCompiler();
+    }
+    createAdapter() {
+        return new PostgresAdapter();
+    }
+    createIntrospector(db) {
+        class NullIntrospector {
+            async getSchemas() {
+                return [];
             }
+            async getTables(options) {
+                options?.withInternalKyselyTables;
+                return [];
+            }
+            async getMetadata(options) {
+                options?.withInternalKyselyTables;
+                return {
+                    tables: []
+                };
+            }
+        }
+        return new NullIntrospector();
+    }
+}
+const isSelectItem = (item)=>'object' == typeof item && 'field' in item;
+const escapeValue = (value)=>{
+    if (null === value) return 'null';
+    if ('string' == typeof value) return `'${value.replace(/'/g, "''")}'`;
+    if ('number' == typeof value) return `${value}`;
+    if ('boolean' == typeof value) return value ? 'TRUE' : 'FALSE';
+    return `'${String(value).replace(/'/g, "''")}'`;
+};
+const inlineParameters = (sql, params)=>{
+    if (0 === params.length) return sql;
+    if (sql.includes('?')) {
+        let out = sql;
+        for (const p of params)out = out.replace(/\?/, escapeValue(p));
+        return out;
+    }
+    if (/\$\d+/.test(sql)) return sql.replace(/\$(\d+)/g, (_, idx)=>{
+        const i = Number(idx) - 1;
+        const v = params[i];
+        return escapeValue(v);
+    });
+    return sql;
+};
+const applyWhere = (where)=>{
+    const toRaw = (w)=>{
+        if ('op' in w && 'conditions' in w) {
+            const parts = w.conditions.map((c)=>toRaw(c));
+            const sep = external_kysely_sql` ${external_kysely_sql.raw(w.op)} `;
+            return external_kysely_sql`(${external_kysely_sql.join(parts, sep)})`;
         }
-        if (isStringOrNumber(value)) {
-            const value0 = value;
-            return `${field} ${op} ${escape(value0)}`;
+        const leaf = w;
+        const field = leaf.field;
+        const value = leaf.value;
+        switch(leaf.op){
+            case 'is null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
+            case 'is not null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is not null`;
+            case 'in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'not in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`not ${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} between (${external_kysely_sql.val(a)}, ${external_kysely_sql.val(b)})`;
+                }
+            case 'not between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`not ${external_kysely_sql.ref(field)} between (${external_kysely_sql.val(a)}, ${external_kysely_sql.val(b)})`;
+                }
+            default:
+                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(leaf.op)} ${external_kysely_sql.val(value)}`;
         }
+    };
+    return toRaw(where);
+};
+const applyGroupBy = (qb, fields)=>{
+    if (fields && fields.length > 0) {
+        const exprs = fields.map((f)=>external_kysely_sql.id(f));
+        qb = qb.groupBy(exprs);
     }
-    return '';
+    return qb;
+};
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
 };
 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;
+    const db = new Kysely({
+        dialect: new PostgresDialect()
+    });
+    let qb = db.selectFrom(tableName);
+    qb = dsl.select && dsl.select.length > 0 ? qb.select((eb)=>dsl.select.map((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;
+                const field = item.field;
+                if (item.func) {
+                    const alias = item.alias ?? field;
+                    switch(item.func){
+                        case 'avg':
+                            return eb.fn.avg(field).as(alias);
+                        case 'sum':
+                            return eb.fn.sum(field).as(alias);
+                        case 'min':
+                            return eb.fn.min(field).as(alias);
+                        case 'max':
+                            return eb.fn.max(field).as(alias);
+                        case 'count':
+                            return eb.fn.count(field).as(alias);
+                    }
+                }
+                return item.alias ? eb.ref(field).as(item.alias) : 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;
+            return item;
+        })) : qb.selectAll();
+    if (dsl.where) qb = qb.where(applyWhere(dsl.where));
+    qb = applyGroupBy(qb, dsl.groupBy);
+    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy)qb = qb.orderBy(o.field, o.order ?? 'asc');
+    qb = applyLimit(qb, dsl.limit);
+    const compiled = qb.compile();
+    return inlineParameters(compiled.sql, compiled.parameters);
 };
 class Dataset {
     duckDB;
@@ -67,7 +150,13 @@ class Dataset {
         this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
     }
-    async init(temporaryStructs) {
+    async init(temporaryColumns = []) {
+        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
+        const columns = temporaryColumns.length > 0 ? temporaryColumns : datasetInfo.datasetSchema.columns;
+        if (columns.length > 0) await this.createOrReplaceView(columns);
+    }
+    async createOrReplaceView(columns = []) {
         const readFunctionMap = {
             csv: 'read_csv_auto',
             json: 'read_json_auto',
@@ -83,16 +172,20 @@ class Dataset {
         };
         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);
+        const { datasetSource: dataSource } = datasetInfo;
+        if (dataSource) {
+            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 query(queryDSL) {
+        const sql = convertDSLToSQL(queryDSL, this.datasetId);
+        return this.queryBySQL(sql);
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
@@ -107,14 +200,6 @@ 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}"`);
     }
@@ -213,7 +298,7 @@ class IndexedDB {
             this.db = null;
         }
     };
-    writeDataset = (datasetId, dataSource, datasetSchema)=>new Promise((resolve, reject)=>{
+    writeDataset = (datasetId, datasetSchema, datasetSource)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
                 this.datasetStoreName
@@ -221,8 +306,8 @@ class IndexedDB {
             const store = transaction.objectStore(this.datasetStoreName);
             const request = store.put({
                 datasetId,
-                dataSource,
-                datasetSchema
+                datasetSchema,
+                datasetSource
             });
             request.onsuccess = ()=>{
                 resolve();
@@ -279,18 +364,18 @@ class IndexedDB {
 const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
 const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
 const isBase64Url = (url)=>url.startsWith('data:');
-class DataSourceBuilder {
+class DatasetSourceBuilder {
     type;
     value;
-    constructor(type, value){
-        this.type = type;
-        this.value = value;
+    constructor(raw){
+        this.type = raw.type;
+        this.value = raw.rawDataset;
     }
-    static from(type, value) {
-        return new DataSourceBuilder(type, value);
+    static from(raw) {
+        return new DatasetSourceBuilder(raw);
     }
     async build() {
-        const blob = await DataSourceBuilder.convertToBlob(this.type, this.value);
+        const blob = await DatasetSourceBuilder.convertToBlob(this.type, this.value);
         return {
             type: this.type,
             blob: blob
@@ -304,7 +389,7 @@ class DataSourceBuilder {
             ], {
                 type: 'text/csv'
             });
-            if ('string' == typeof csvSource && isUrl(csvSource)) return DataSourceBuilder.fetchBlob(csvSource);
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DatasetSourceBuilder.fetchBlob(csvSource);
             return new Blob([
                 JSON.stringify(csvSource)
             ], {
@@ -317,7 +402,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/json'
             });
-            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DataSourceBuilder.fetchBlob(jsonSource);
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DatasetSourceBuilder.fetchBlob(jsonSource);
             return new Blob([
                 JSON.stringify(jsonSource)
             ], {
@@ -330,7 +415,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/parquet'
             });
-            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DataSourceBuilder.fetchBlob(parquetSource);
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DatasetSourceBuilder.fetchBlob(parquetSource);
             return new Blob([
                 parquetSource
             ], {
@@ -343,7 +428,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
             });
-            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DataSourceBuilder.fetchBlob(xlsxSource);
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DatasetSourceBuilder.fetchBlob(xlsxSource);
             return new Blob([
                 xlsxSource
             ], {
@@ -378,46 +463,62 @@ class VQuery {
         this.duckDB = new DuckDB();
         this.indexedDB = new IndexedDB(dbName);
     }
-    async ensureInitialized() {
+    async checkInitialized() {
         if (!this.isInitialized) {
             await this.duckDB.init();
             await this.indexedDB.open();
             this.isInitialized = true;
         }
     }
-    async createDataset(datasetId, data, type, datasetSchema) {
-        await this.ensureInitialized();
-        const dataSource = await DataSourceBuilder.from(type, data).build();
-        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+    async checkDatasetExists(datasetId) {
+        if (!await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} not exists, please create it first`);
     }
-    async updateDataset(datasetId, data, type, datasetSchema) {
-        await this.ensureInitialized();
-        const dataSource = await DataSourceBuilder.from(type, data).build();
-        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+    async createDataset(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        if (await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} already exists`);
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
-    async deleteDataset(datasetId) {
-        await this.ensureInitialized();
-        await this.indexedDB.deleteDataset(datasetId);
+    async updateDatasetSource(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
-    async listDatasets() {
-        await this.ensureInitialized();
-        return this.indexedDB.listDatasets();
+    async dropDataset(datasetId) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        await this.indexedDB.deleteDataset(datasetId);
     }
-    async connectDataset(datasetId) {
-        await this.ensureInitialized();
+    async connectDataset(datasetId, temporaryColumns = []) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
         const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init();
+        await dataset.init(temporaryColumns);
         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 hasDataset(datasetId) {
+        await this.checkInitialized();
+        const datasets = await this.indexedDB.listDatasets();
+        return datasets.some((item)=>item.datasetId === datasetId);
+    }
+    async listDatasets() {
+        await this.checkInitialized();
+        return this.indexedDB.listDatasets();
     }
     async close() {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         await this.duckDB.close();
     }
 }
-export { DataSourceBuilder, VQuery, isBase64Url, isHttpUrl, isUrl };
+export { DatasetSourceBuilder, VQuery, convertDSLToSQL, isBase64Url, isHttpUrl, isUrl };

package/dist/sql-builder/builders/groupBy.d.ts

@@ -0,0 +1,2 @@
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyGroupBy: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, fields?: Array<string>) => SelectQueryBuilder<DB, TB, O>;

package/dist/sql-builder/builders/index.d.ts

@@ -0,0 +1,3 @@
+export { applyWhere } from './where';
+export { applyGroupBy } from './groupBy';
+export { applyLimit } from './limit';

package/dist/sql-builder/builders/limit.d.ts

@@ -0,0 +1,2 @@
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyLimit: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, limit?: number) => SelectQueryBuilder<DB, TB, O>;

package/dist/{dataset/convert/applyWhere.d.ts → sql-builder/builders/where.d.ts}

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

package/dist/sql-builder/compile/index.d.ts

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

package/dist/sql-builder/compile/inlineParameters.d.ts

@@ -0,0 +1 @@
+export declare const inlineParameters: (sql: string, params: readonly unknown[]) => string;

package/dist/sql-builder/dialect/index.d.ts

@@ -0,0 +1 @@
+export { PostgresDialect } from './postgresDialect';

package/dist/sql-builder/dialect/postgresDialect.d.ts

@@ -0,0 +1,11 @@
+import { Dialect, DummyDriver } from 'kysely';
+import { PostgresQueryCompiler } from 'kysely';
+import { PostgresAdapter } from 'kysely';
+import { Kysely } from 'kysely';
+import type { DatabaseIntrospector } from 'kysely';
+export declare class PostgresDialect implements Dialect {
+    createDriver(): DummyDriver;
+    createQueryCompiler(): PostgresQueryCompiler;
+    createAdapter(): PostgresAdapter;
+    createIntrospector<DB = unknown>(db: Kysely<DB>): DatabaseIntrospector;
+}

package/dist/sql-builder/dslToSQL.d.ts

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

package/dist/sql-builder/index.d.ts

@@ -0,0 +1 @@
+export { convertDSLToSQL } from './dslToSQL';

package/dist/{dataset/convert → sql-builder}/utils.d.ts

@@ -1,6 +1,8 @@
-import { Where, WhereClause, WhereGroup, WhereLeaf } from '../../types';
-import { SelectItem } from '../../types/QueryDSL/Select';
+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;
+export declare const escapeLiteral: <T>(value: T[keyof T]) => T[keyof T];
+export declare const escapeValue: (value: unknown) => string;

package/dist/types/DataSource.d.ts

@@ -1,7 +1,11 @@
 export type TidyDatum = Record<string, number | string | null | boolean | undefined>;
-export type DataSourceType = 'csv' | 'json' | 'xlsx' | 'parquet';
-export type DataSourceValue = string | ArrayBuffer | Blob | TidyDatum[];
-export interface DataSource {
-    type: DataSourceType;
+export type DatasetSourceType = 'csv' | 'json' | 'xlsx' | 'parquet';
+export type DatasetSourceValue = string | ArrayBuffer | Blob | TidyDatum[];
+export interface DatasetSource {
+    type: DatasetSourceType;
     blob: Blob;
 }
+export interface RawDatasetSource {
+    type: DatasetSourceType;
+    rawDataset: DatasetSourceValue;
+}

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

@@ -12,7 +12,7 @@ export type WhereLeaf<T> = {
         } & (O extends 'is null' | 'is not null' ? {
             value?: never;
         } : O extends 'in' | 'not in' ? {
-            value: T[K][];
+            value: T[K] | T[K][];
         } : O extends 'between' | 'not between' ? {
             value: [T[K], T[K]];
         } : {

package/dist/vquery.d.ts

@@ -1,43 +1,21 @@
 import { Dataset } from './dataset/dataset';
-import { DatasetSchema, TidyDatum, DataSourceType, DatasetColumn } from './types';
+import { RawDatasetSource, DatasetColumn } from './types';
 export declare class VQuery {
     private duckDB;
     private indexedDB;
     private isInitialized;
     constructor(dbName?: string);
-    private ensureInitialized;
-    /**
-     * 创建数据集，根据表结构和数据，存储信息到indexedDB
-     */
-    createDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, datasetSchema: DatasetSchema): Promise<void>;
-    /**
-     * 修改数据集，更新信息到indexedDB内
-     */
-    updateDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, datasetSchema: DatasetSchema): Promise<void>;
-    /**
-     * 删除数据集，从indexdb移除数据集
-     */
-    deleteDataset(datasetId: string): Promise<void>;
-    /**
-     * 获取所有可用数据集
-     */
+    private checkInitialized;
+    private checkDatasetExists;
+    createDataset(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
+    updateDatasetSource(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
+    dropDataset(datasetId: string): Promise<void>;
+    connectDataset(datasetId: string, temporaryColumns?: DatasetColumn[]): Promise<Dataset>;
+    hasDataset(datasetId: string): Promise<boolean>;
     listDatasets(): Promise<{
         datasetId: string;
-        dataSource: import("./types").DataSource;
-        datasetSchema: DatasetSchema;
+        dataSource?: import("./types").DatasetSource;
+        datasetSchema: import("./types").DatasetSchema;
     }[]>;
-    /**
-     * 连接数据集，返回数据集信息，从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.48",
+  "version": "0.1.50",
   "type": "module",
   "exports": {
     ".": {
@@ -15,14 +15,15 @@
     "dist"
   ],
   "dependencies": {
-    "@duckdb/duckdb-wasm": "1.30.0"
+    "@duckdb/duckdb-wasm": "1.30.0",
+    "kysely": "^0.27.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.35.0",
     "@rslib/core": "^0.15.1",
-    "@rstest/core": "^0.5.1",
+    "@rstest/core": "0.6.5",
     "@types/node": "^22.18.10",
-    "@rstest/coverage-istanbul": "^0.0.2",
+    "@rstest/coverage-istanbul": "0.0.5",
     "eslint": "^9.35.0",
     "globals": "^16.3.0",
     "typescript": "^5.9.3",
@@ -33,6 +34,8 @@
     "dev": "rslib build --watch",
     "lint": "eslint .",
     "test": "rstest",
+    "test:update": "rstest --update",
+    "test:coverage": "rstest --coverage && open ./coverage/index.html",
     "type-check": "tsc --noEmit"
   }
 }

package/dist/dataSourceBuilder/dataSourceBuilder.d.ts

@@ -1,16 +0,0 @@
-import { DataSourceType, DataSourceValue } from '../types';
-export declare class DataSourceBuilder {
-    private type;
-    private value;
-    constructor(type: DataSourceType, value: DataSourceValue);
-    static from(type: DataSourceType, value: DataSourceValue): DataSourceBuilder;
-    build(): Promise<{
-        type: DataSourceType;
-        blob: Blob;
-    }>;
-    /**
-     * 将不同类型的数据转换为Blob
-     */
-    private static convertToBlob;
-    private static fetchBlob;
-}

package/dist/dataSourceBuilder/index.d.ts

@@ -1 +0,0 @@
-export { DataSourceBuilder } from './dataSourceBuilder';

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

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