@visactor/vquery 0.1.47 → 0.1.49

package/dist/dataset/dataset.d.ts

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

package/dist/dataset/index.d.ts

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

package/dist/index.cjs

@@ -29,10 +29,153 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     DataSourceBuilder: ()=>DataSourceBuilder,
     isHttpUrl: ()=>isHttpUrl,
+    convertDSLToSQL: ()=>convertDSLToSQL,
     isBase64Url: ()=>isBase64Url,
     isUrl: ()=>isUrl,
     VQuery: ()=>VQuery
 });
+const external_kysely_namespaceObject = require("kysely");
+class PostgresDialect {
+    createDriver() {
+        return new external_kysely_namespaceObject.DummyDriver();
+    }
+    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)})`;
+        }
+        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 qb;
+};
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
+};
+const convertDSLToSQL = (dsl, tableName)=>{
+    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)) {
+                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;
+            }
+            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;
     indexedDB;
@@ -42,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',
@@ -60,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);
@@ -82,6 +225,13 @@ class Dataset {
             }
         };
     }
+    convertDSLToSQL(queryDSL) {
+        return convertDSLToSQL(queryDSL, this.datasetId);
+    }
+    async query(queryDSL) {
+        const sql = this.convertDSLToSQL(queryDSL);
+        return this.queryBySQL(sql);
+    }
     async disconnect() {
         await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
     }
@@ -353,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) {
@@ -363,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() {
@@ -390,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,4 +1,146 @@
+import { DummyDriver, Kysely, PostgresAdapter, PostgresQueryCompiler, sql as external_kysely_sql } from "kysely";
 import { AsyncDuckDB, ConsoleLogger, selectBundle } from "@duckdb/duckdb-wasm";
+class PostgresDialect {
+    createDriver() {
+        return new DummyDriver();
+    }
+    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)})`;
+        }
+        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 qb;
+};
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
+};
+const convertDSLToSQL = (dsl, tableName)=>{
+    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)) {
+                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;
+            }
+            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;
     indexedDB;
@@ -8,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',
@@ -26,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);
@@ -48,6 +190,13 @@ class Dataset {
             }
         };
     }
+    convertDSLToSQL(queryDSL) {
+        return convertDSLToSQL(queryDSL, this.datasetId);
+    }
+    async query(queryDSL) {
+        const sql = this.convertDSLToSQL(queryDSL);
+        return this.queryBySQL(sql);
+    }
     async disconnect() {
         await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
     }
@@ -318,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) {
@@ -328,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() {
@@ -353,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/sql-builder/builders/where.d.ts

@@ -0,0 +1,3 @@
+import { Where, WhereClause } from '../../types';
+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/sql-builder/utils.d.ts

@@ -0,0 +1,8 @@
+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/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] | 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

@@ -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.47",
+  "version": "0.1.49",
   "type": "module",
   "exports": {
     ".": {
@@ -15,14 +15,15 @@
     "dist"
   ],
   "dependencies": {
-    "@duckdb/duckdb-wasm": "latest"
+    "@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"
   }
 }