@visactor/vquery 0.1.48 → 0.1.49

package/dist/dataset/dataset.d.ts

@@ -6,7 +6,7 @@ export declare class Dataset {
     private indexedDB;
     private _datasetId;
     constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
-    init(temporaryStructs?: DatasetColumn[]): Promise<void>;
+    init(temporaryColumns?: DatasetColumn[]): Promise<void>;
     queryBySQL(sql: string): Promise<{
         performance: {
             startAt: string;

package/dist/dataset/index.d.ts

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

package/dist/index.cjs

@@ -29,68 +29,152 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DataSourceBuilder: ()=>DataSourceBuilder,
     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: []
+                };
             }
         }
-        if (isStringOrNumber(value)) {
-            const value0 = value;
-            return `${field} ${op} ${escape(value0)}`;
+        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)})`;
+        }
+        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,7 @@ class Dataset {
         this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
     }
-    async init(temporaryStructs) {
+    async init(temporaryColumns = []) {
         const readFunctionMap = {
             csv: 'read_csv_auto',
             json: 'read_json_auto',
@@ -119,7 +203,7 @@ class Dataset {
         if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
         const { dataSource } = datasetInfo;
         const datasetSchema = datasetInfo.datasetSchema;
-        const columns = temporaryStructs || datasetSchema.columns;
+        const columns = temporaryColumns.length > 0 ? temporaryColumns : 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);
@@ -146,7 +230,6 @@ class Dataset {
     }
     async query(queryDSL) {
         const sql = this.convertDSLToSQL(queryDSL);
-        console.log(sql);
         return this.queryBySQL(sql);
     }
     async disconnect() {
@@ -420,9 +503,14 @@ class VQuery {
             this.isInitialized = true;
         }
     }
-    async createDataset(datasetId, data, type, datasetSchema) {
+    async createDataset(datasetId, data, type, columns = []) {
         await this.ensureInitialized();
         const dataSource = await DataSourceBuilder.from(type, data).build();
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
         await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
     }
     async updateDataset(datasetId, data, type, datasetSchema) {
@@ -430,24 +518,23 @@ class VQuery {
         const dataSource = await DataSourceBuilder.from(type, data).build();
         await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
     }
-    async deleteDataset(datasetId) {
+    async dropDataset(datasetId) {
         await this.ensureInitialized();
         await this.indexedDB.deleteDataset(datasetId);
     }
-    async listDatasets() {
+    async hasDataset(datasetId) {
         await this.ensureInitialized();
-        return this.indexedDB.listDatasets();
+        const datasets = await this.indexedDB.listDatasets();
+        return datasets.some((item)=>item.datasetId === datasetId);
     }
-    async connectDataset(datasetId) {
+    async listDatasets() {
         await this.ensureInitialized();
-        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init();
-        return dataset;
+        return this.indexedDB.listDatasets();
     }
-    async connectTemporaryDataset(datasetId, temporaryDatasetSchema) {
+    async connectDataset(datasetId, temporaryColumns = []) {
         await this.ensureInitialized();
         const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init(temporaryDatasetSchema);
+        await dataset.init(temporaryColumns);
         return dataset;
     }
     async close() {
@@ -457,12 +544,14 @@ class VQuery {
 }
 exports.DataSourceBuilder = __webpack_exports__.DataSourceBuilder;
 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",
     "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 { DataSourceBuilder } 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: []
+                };
             }
         }
-        if (isStringOrNumber(value)) {
-            const value0 = value;
-            return `${field} ${op} ${escape(value0)}`;
+        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)})`;
+        }
+        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,7 @@ class Dataset {
         this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
     }
-    async init(temporaryStructs) {
+    async init(temporaryColumns = []) {
         const readFunctionMap = {
             csv: 'read_csv_auto',
             json: 'read_json_auto',
@@ -85,7 +168,7 @@ class Dataset {
         if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
         const { dataSource } = datasetInfo;
         const datasetSchema = datasetInfo.datasetSchema;
-        const columns = temporaryStructs || datasetSchema.columns;
+        const columns = temporaryColumns.length > 0 ? temporaryColumns : 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);
@@ -112,7 +195,6 @@ class Dataset {
     }
     async query(queryDSL) {
         const sql = this.convertDSLToSQL(queryDSL);
-        console.log(sql);
         return this.queryBySQL(sql);
     }
     async disconnect() {
@@ -385,9 +467,14 @@ class VQuery {
             this.isInitialized = true;
         }
     }
-    async createDataset(datasetId, data, type, datasetSchema) {
+    async createDataset(datasetId, data, type, columns = []) {
         await this.ensureInitialized();
         const dataSource = await DataSourceBuilder.from(type, data).build();
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
         await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
     }
     async updateDataset(datasetId, data, type, datasetSchema) {
@@ -395,24 +482,23 @@ class VQuery {
         const dataSource = await DataSourceBuilder.from(type, data).build();
         await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
     }
-    async deleteDataset(datasetId) {
+    async dropDataset(datasetId) {
         await this.ensureInitialized();
         await this.indexedDB.deleteDataset(datasetId);
     }
-    async listDatasets() {
+    async hasDataset(datasetId) {
         await this.ensureInitialized();
-        return this.indexedDB.listDatasets();
+        const datasets = await this.indexedDB.listDatasets();
+        return datasets.some((item)=>item.datasetId === datasetId);
     }
-    async connectDataset(datasetId) {
+    async listDatasets() {
         await this.ensureInitialized();
-        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init();
-        return dataset;
+        return this.indexedDB.listDatasets();
     }
-    async connectTemporaryDataset(datasetId, temporaryDatasetSchema) {
+    async connectDataset(datasetId, temporaryColumns = []) {
         await this.ensureInitialized();
         const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init(temporaryDatasetSchema);
+        await dataset.init(temporaryColumns);
         return dataset;
     }
     async close() {
@@ -420,4 +506,4 @@ class VQuery {
         await this.duckDB.close();
     }
 }
-export { DataSourceBuilder, VQuery, isBase64Url, isHttpUrl, isUrl };
+export { DataSourceBuilder, 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/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

@@ -9,7 +9,7 @@ export declare class VQuery {
     /**
      * 创建数据集，根据表结构和数据，存储信息到indexedDB
      */
-    createDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, datasetSchema: DatasetSchema): Promise<void>;
+    createDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, columns?: DatasetColumn[]): Promise<void>;
     /**
      * 修改数据集，更新信息到indexedDB内
      */
@@ -17,7 +17,11 @@ export declare class VQuery {
     /**
      * 删除数据集，从indexdb移除数据集
      */
-    deleteDataset(datasetId: string): Promise<void>;
+    dropDataset(datasetId: string): Promise<void>;
+    /**
+     * 检查数据集是否存在
+     */
+    hasDataset(datasetId: string): Promise<boolean>;
     /**
      * 获取所有可用数据集
      */
@@ -29,13 +33,7 @@ export declare class VQuery {
     /**
      * 连接数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
      */
-    connectDataset(datasetId: string): Promise<Dataset>;
-    /**
-     * 连接临时数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
-     * @param datasetId
-     * @returns
-     */
-    connectTemporaryDataset(datasetId: string, temporaryDatasetSchema?: DatasetColumn[]): Promise<Dataset>;
+    connectDataset(datasetId: string, temporaryColumns?: DatasetColumn[]): Promise<Dataset>;
     /**
      * 关闭所有数据集连接，释放DuckDB资源
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vquery",
-  "version": "0.1.48",
+  "version": "0.1.49",
   "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/dataset/convert/dslToSQL.d.ts

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