@visactor/vquery 0.1.46 → 0.1.47

package/dist/{dataset.d.ts → dataset/dataset.d.ts}

@@ -1,9 +1,12 @@
-import { DuckDB } from './db/duckDb';
+import { DatasetColumn } from '../types';
+import { DuckDB } from '../db/duckDb';
+import { IndexedDB } from '../db/indexedDb';
 export declare class Dataset {
     private duckDB;
+    private indexedDB;
     private _datasetId;
-    private _tableName;
-    constructor(duckDB: DuckDB, datasetId: string, tableName: string);
+    constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
+    init(temporaryStructs?: DatasetColumn[]): Promise<void>;
     queryBySQL(sql: string): Promise<{
         performance: {
             startAt: string;
@@ -13,7 +16,6 @@ export declare class Dataset {
         dataset: any[];
         table: any;
     }>;
-    disConnect(): Promise<void>;
+    disconnect(): Promise<void>;
     get datasetId(): string;
-    get tableName(): string;
 }

package/dist/dataset/index.d.ts

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/vquery.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vquery",
-  "version": "0.1.46",
+  "version": "0.1.47",
   "type": "module",
   "exports": {
     ".": {