@visactor/vquery 0.1.45 → 0.1.47

package/dist/dataSourceBuilder/dataSourceBuilder.d.ts

@@ -0,0 +1,16 @@
+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

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

package/dist/dataset/dataset.d.ts

@@ -0,0 +1,21 @@
+import { DatasetColumn } from '../types';
+import { DuckDB } from '../db/duckDb';
+import { IndexedDB } from '../db/indexedDb';
+export declare class Dataset {
+    private duckDB;
+    private indexedDB;
+    private _datasetId;
+    constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
+    init(temporaryStructs?: DatasetColumn[]): Promise<void>;
+    queryBySQL(sql: string): Promise<{
+        performance: {
+            startAt: string;
+            endAt: string;
+            duration: number;
+        };
+        dataset: any[];
+        table: any;
+    }>;
+    disconnect(): Promise<void>;
+    get datasetId(): string;
+}

package/dist/dataset/index.d.ts

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

package/dist/db/duckDb.d.ts

@@ -1,4 +1,4 @@
-import { QueryResult } from '../types';
+import { QueryResult } from '../types/DataSet';
 export declare class DuckDB {
     private db;
     private connection;
@@ -16,7 +16,7 @@ export declare class DuckDB {
      * @param fileName 文件名
      * @param source 文件内容
      */
-    writeFile: <T extends string | ArrayBuffer | Uint8Array | Blob>(fileName: string, source: T) => Promise<void>;
+    writeFile: <T extends Blob>(fileName: string, source: T) => Promise<void>;
     /**
      * @description 执行 SQL 查询
      * @param sql SQL 语句
@@ -26,11 +26,6 @@ export declare class DuckDB {
         dataset: any[];
         table: any;
     }>;
-    /**
-     * 确保一个文件存在，如果不存在，则根据同名文件创建临时表
-     * @param fileName 文件名
-     */
-    private ensureSchema;
     /**
      * @description 获取文件的 Schema
      * @param fileName 文件名

package/dist/db/indexedDb.d.ts

@@ -1,11 +1,21 @@
+import { DataSource } from '../types';
+import { DatasetSchema } from '../types/DataSet';
 export declare class IndexedDB {
     private db;
     private dbName;
-    private storeName;
+    private datasetStoreName;
     constructor(dbName: string);
     open: () => Promise<void>;
     close: () => void;
-    writeFile: (fileName: string, data: Blob) => Promise<void>;
-    readFile: (fileName: string) => Promise<Blob | null>;
-    listFiles: () => Promise<string[]>;
+    writeDataset: (datasetId: string, dataSource: DataSource, datasetSchema: DatasetSchema) => Promise<void>;
+    readDataset: (datasetId: string) => Promise<{
+        dataSource: DataSource;
+        datasetSchema: DatasetSchema;
+    } | null>;
+    deleteDataset: (datasetId: string) => Promise<void>;
+    listDatasets: () => Promise<{
+        datasetId: string;
+        dataSource: DataSource;
+        datasetSchema: DatasetSchema;
+    }[]>;
 }

package/dist/index.cjs

@@ -27,8 +27,68 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    DataSourceBuilder: ()=>DataSourceBuilder,
+    isHttpUrl: ()=>isHttpUrl,
+    isBase64Url: ()=>isBase64Url,
+    isUrl: ()=>isUrl,
     VQuery: ()=>VQuery
 });
+class Dataset {
+    duckDB;
+    indexedDB;
+    _datasetId;
+    constructor(duckDB, indexedDB1, datasetId){
+        this.duckDB = duckDB;
+        this.indexedDB = indexedDB1;
+        this._datasetId = datasetId;
+    }
+    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);
+        const result = await this.duckDB.query(sql);
+        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        return {
+            ...result,
+            performance: {
+                startAt: start,
+                endAt: end,
+                duration: Number(end) - Number(start)
+            }
+        };
+    }
+    async disconnect() {
+        await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
+    }
+    get datasetId() {
+        return this._datasetId;
+    }
+}
 const duckdb_wasm_namespaceObject = require("@duckdb/duckdb-wasm");
 class DuckDB {
     db = null;
@@ -71,16 +131,10 @@ class DuckDB {
     writeFile = async (fileName, source)=>{
         if (!this.db) throw new Error('db is null');
         let uint8Array;
-        if ('string' == typeof source) {
-            const response = await fetch(source);
-            const buffer = await response.arrayBuffer();
-            uint8Array = new Uint8Array(buffer);
-        } else if (source instanceof Blob) {
+        if (source instanceof Blob) {
             const buffer = await source.arrayBuffer();
             uint8Array = new Uint8Array(buffer);
-        } else if (source instanceof ArrayBuffer) uint8Array = new Uint8Array(source);
-        else if (source instanceof Uint8Array) uint8Array = source;
-        else throw new Error('Unsupported source type');
+        } else throw new Error('Unsupported source type');
         await this.db.registerFileBuffer(fileName, uint8Array);
     };
     query = async (sql)=>{
@@ -92,13 +146,8 @@ class DuckDB {
             table
         };
     };
-    ensureSchema = async (fileName)=>{
-        if (!this.connection) throw new Error('connection is null');
-        await this.connection.query(`CREATE TEMP TABLE IF NOT EXISTS "${fileName}" AS SELECT * FROM read_csv_auto('${fileName}')`);
-    };
     getSchema = async (fileName)=>{
         if (!this.connection) throw new Error('connection is null');
-        await this.ensureSchema(fileName);
         const result = await this.connection.query(`PRAGMA table_info('${fileName}')`);
         return result.toArray().map((row)=>row.toJSON());
     };
@@ -106,16 +155,16 @@ class DuckDB {
 class IndexedDB {
     db = null;
     dbName;
-    storeName = 'vqueryFiles';
+    datasetStoreName = 'vqueryDatasets';
     constructor(dbName){
         this.dbName = dbName;
     }
     open = ()=>new Promise((resolve, reject)=>{
-            const request = indexedDB.open(this.dbName, 1);
+            const request = indexedDB.open(this.dbName, 2);
             request.onupgradeneeded = (event)=>{
                 const db = event.target.result;
-                if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName, {
-                    keyPath: 'name'
+                if (!db.objectStoreNames.contains(this.datasetStoreName)) db.createObjectStore(this.datasetStoreName, {
+                    keyPath: 'datasetId'
                 });
             };
             request.onsuccess = (event)=>{
@@ -132,15 +181,16 @@ class IndexedDB {
             this.db = null;
         }
     };
-    writeFile = (fileName, data)=>new Promise((resolve, reject)=>{
+    writeDataset = (datasetId, dataSource, datasetSchema)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
-                this.storeName
+                this.datasetStoreName
             ], 'readwrite');
-            const store = transaction.objectStore(this.storeName);
+            const store = transaction.objectStore(this.datasetStoreName);
             const request = store.put({
-                name: fileName,
-                data
+                datasetId,
+                dataSource,
+                datasetSchema
             });
             request.onsuccess = ()=>{
                 resolve();
@@ -149,92 +199,206 @@ class IndexedDB {
                 reject(event.target.error);
             };
         });
-    readFile = (fileName)=>new Promise((resolve, reject)=>{
+    readDataset = (datasetId)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
-                this.storeName
+                this.datasetStoreName
             ], 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.get(fileName);
+            const store = transaction.objectStore(this.datasetStoreName);
+            const request = store.get(datasetId);
             request.onsuccess = (event)=>{
                 const result = event.target.result;
-                result ? resolve(result.data) : resolve(null);
+                resolve(result || null);
             };
             request.onerror = (event)=>{
                 reject(event.target.error);
             };
         });
-    listFiles = ()=>new Promise((resolve, reject)=>{
+    deleteDataset = (datasetId)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
-                this.storeName
+                this.datasetStoreName
+            ], 'readwrite');
+            const store = transaction.objectStore(this.datasetStoreName);
+            const request = store.delete(datasetId);
+            request.onsuccess = ()=>{
+                resolve();
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    listDatasets = ()=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.datasetStoreName
             ], 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.getAllKeys();
+            const store = transaction.objectStore(this.datasetStoreName);
+            const request = store.getAll();
             request.onsuccess = (event)=>{
-                const keys = event.target.result;
-                resolve(keys);
+                const result = event.target.result;
+                resolve(result);
             };
             request.onerror = (event)=>{
                 reject(event.target.error);
             };
         });
 }
+const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
+const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
+const isBase64Url = (url)=>url.startsWith('data:');
+class DataSourceBuilder {
+    type;
+    value;
+    constructor(type, value){
+        this.type = type;
+        this.value = value;
+    }
+    static from(type, value) {
+        return new DataSourceBuilder(type, value);
+    }
+    async build() {
+        const blob = await DataSourceBuilder.convertToBlob(this.type, this.value);
+        return {
+            type: this.type,
+            blob: blob
+        };
+    }
+    static async convertToBlob(type, value) {
+        if (value instanceof Blob) return value;
+        const convertCsvToBlob = (csvSource)=>{
+            if (csvSource instanceof ArrayBuffer) return new Blob([
+                csvSource
+            ], {
+                type: 'text/csv'
+            });
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DataSourceBuilder.fetchBlob(csvSource);
+            return new Blob([
+                JSON.stringify(csvSource)
+            ], {
+                type: 'text/csv'
+            });
+        };
+        const convertJsonToBlob = (jsonSource)=>{
+            if (jsonSource instanceof ArrayBuffer) return new Blob([
+                jsonSource
+            ], {
+                type: 'application/json'
+            });
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DataSourceBuilder.fetchBlob(jsonSource);
+            return new Blob([
+                JSON.stringify(jsonSource)
+            ], {
+                type: 'application/json'
+            });
+        };
+        const convertParquetToBlob = (parquetSource)=>{
+            if (parquetSource instanceof ArrayBuffer) return new Blob([
+                parquetSource
+            ], {
+                type: 'application/parquet'
+            });
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DataSourceBuilder.fetchBlob(parquetSource);
+            return new Blob([
+                parquetSource
+            ], {
+                type: 'application/parquet'
+            });
+        };
+        const convertXlsxToBlob = (xlsxSource)=>{
+            if (xlsxSource instanceof ArrayBuffer) return new Blob([
+                xlsxSource
+            ], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            });
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DataSourceBuilder.fetchBlob(xlsxSource);
+            return new Blob([
+                xlsxSource
+            ], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            });
+        };
+        switch(type){
+            case 'csv':
+                return convertCsvToBlob(value);
+            case 'json':
+                return convertJsonToBlob(value);
+            case 'xlsx':
+                return convertXlsxToBlob(value);
+            case 'parquet':
+                return convertParquetToBlob(value);
+            default:
+                return new Blob([
+                    value
+                ]);
+        }
+    }
+    static async fetchBlob(url) {
+        const response = await fetch(url);
+        return await response.blob();
+    }
+}
 class VQuery {
     duckDB;
     indexedDB;
+    isInitialized = false;
     constructor(dbName = 'vquery'){
         this.duckDB = new DuckDB();
         this.indexedDB = new IndexedDB(dbName);
     }
-    init = async ()=>{
-        await this.duckDB.init();
-        await this.indexedDB.open();
-    };
-    close = async ()=>{
+    async ensureInitialized() {
+        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 updateDataset(datasetId, data, type, datasetSchema) {
+        await this.ensureInitialized();
+        const dataSource = await DataSourceBuilder.from(type, data).build();
+        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+    }
+    async deleteDataset(datasetId) {
+        await this.ensureInitialized();
+        await this.indexedDB.deleteDataset(datasetId);
+    }
+    async listDatasets() {
+        await this.ensureInitialized();
+        return this.indexedDB.listDatasets();
+    }
+    async connectDataset(datasetId) {
+        await this.ensureInitialized();
+        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();
-        this.indexedDB.close();
-    };
-    writeFile = async (fileName, source)=>{
-        let blob;
-        if ('string' == typeof source) {
-            const response = await fetch(source);
-            blob = await response.blob();
-        } else if (source instanceof ArrayBuffer) blob = new Blob([
-            source
-        ]);
-        else if (source instanceof Uint8Array) blob = new Blob([
-            source.slice()
-        ]);
-        else if (source instanceof Blob) blob = source;
-        else throw new Error('Unsupported source type');
-        await this.indexedDB.writeFile(fileName, blob);
-        await this.duckDB.writeFile(fileName, blob);
-    };
-    readFile = async (fileName)=>{
-        const blob = await this.indexedDB.readFile(fileName);
-        if (blob) await this.duckDB.writeFile(fileName, blob);
-        else throw new Error(`File ${fileName} not found in IndexedDB`);
-    };
-    listFiles = ()=>this.indexedDB.listFiles();
-    query = async (sql)=>{
-        const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
-        const result = await this.duckDB.query(sql);
-        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
-        return {
-            ...result,
-            performance: {
-                startAt: start,
-                endAt: end,
-                duration: Number(end) - Number(start)
-            }
-        };
-    };
-    getSchema = async (fileName)=>this.duckDB.getSchema(fileName);
+    }
 }
+exports.DataSourceBuilder = __webpack_exports__.DataSourceBuilder;
 exports.VQuery = __webpack_exports__.VQuery;
+exports.isBase64Url = __webpack_exports__.isBase64Url;
+exports.isHttpUrl = __webpack_exports__.isHttpUrl;
+exports.isUrl = __webpack_exports__.isUrl;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "VQuery"
+    "DataSourceBuilder",
+    "VQuery",
+    "isBase64Url",
+    "isHttpUrl",
+    "isUrl"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/index.d.ts

@@ -1 +1,3 @@
 export { VQuery } from './vquery';
+export { DataSourceBuilder } from './dataSourceBuilder/dataSourceBuilder';
+export * from './utils';

package/dist/index.js

@@ -1,4 +1,60 @@
 import { AsyncDuckDB, ConsoleLogger, selectBundle } from "@duckdb/duckdb-wasm";
+class Dataset {
+    duckDB;
+    indexedDB;
+    _datasetId;
+    constructor(duckDB, indexedDB1, datasetId){
+        this.duckDB = duckDB;
+        this.indexedDB = indexedDB1;
+        this._datasetId = datasetId;
+    }
+    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);
+        const result = await this.duckDB.query(sql);
+        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        return {
+            ...result,
+            performance: {
+                startAt: start,
+                endAt: end,
+                duration: Number(end) - Number(start)
+            }
+        };
+    }
+    async disconnect() {
+        await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
+    }
+    get datasetId() {
+        return this._datasetId;
+    }
+}
 class DuckDB {
     db = null;
     connection = null;
@@ -40,16 +96,10 @@ class DuckDB {
     writeFile = async (fileName, source)=>{
         if (!this.db) throw new Error('db is null');
         let uint8Array;
-        if ('string' == typeof source) {
-            const response = await fetch(source);
-            const buffer = await response.arrayBuffer();
-            uint8Array = new Uint8Array(buffer);
-        } else if (source instanceof Blob) {
+        if (source instanceof Blob) {
             const buffer = await source.arrayBuffer();
             uint8Array = new Uint8Array(buffer);
-        } else if (source instanceof ArrayBuffer) uint8Array = new Uint8Array(source);
-        else if (source instanceof Uint8Array) uint8Array = source;
-        else throw new Error('Unsupported source type');
+        } else throw new Error('Unsupported source type');
         await this.db.registerFileBuffer(fileName, uint8Array);
     };
     query = async (sql)=>{
@@ -61,13 +111,8 @@ class DuckDB {
             table
         };
     };
-    ensureSchema = async (fileName)=>{
-        if (!this.connection) throw new Error('connection is null');
-        await this.connection.query(`CREATE TEMP TABLE IF NOT EXISTS "${fileName}" AS SELECT * FROM read_csv_auto('${fileName}')`);
-    };
     getSchema = async (fileName)=>{
         if (!this.connection) throw new Error('connection is null');
-        await this.ensureSchema(fileName);
         const result = await this.connection.query(`PRAGMA table_info('${fileName}')`);
         return result.toArray().map((row)=>row.toJSON());
     };
@@ -75,16 +120,16 @@ class DuckDB {
 class IndexedDB {
     db = null;
     dbName;
-    storeName = 'vqueryFiles';
+    datasetStoreName = 'vqueryDatasets';
     constructor(dbName){
         this.dbName = dbName;
     }
     open = ()=>new Promise((resolve, reject)=>{
-            const request = indexedDB.open(this.dbName, 1);
+            const request = indexedDB.open(this.dbName, 2);
             request.onupgradeneeded = (event)=>{
                 const db = event.target.result;
-                if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName, {
-                    keyPath: 'name'
+                if (!db.objectStoreNames.contains(this.datasetStoreName)) db.createObjectStore(this.datasetStoreName, {
+                    keyPath: 'datasetId'
                 });
             };
             request.onsuccess = (event)=>{
@@ -101,15 +146,16 @@ class IndexedDB {
             this.db = null;
         }
     };
-    writeFile = (fileName, data)=>new Promise((resolve, reject)=>{
+    writeDataset = (datasetId, dataSource, datasetSchema)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
-                this.storeName
+                this.datasetStoreName
             ], 'readwrite');
-            const store = transaction.objectStore(this.storeName);
+            const store = transaction.objectStore(this.datasetStoreName);
             const request = store.put({
-                name: fileName,
-                data
+                datasetId,
+                dataSource,
+                datasetSchema
             });
             request.onsuccess = ()=>{
                 resolve();
@@ -118,87 +164,193 @@ class IndexedDB {
                 reject(event.target.error);
             };
         });
-    readFile = (fileName)=>new Promise((resolve, reject)=>{
+    readDataset = (datasetId)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
-                this.storeName
+                this.datasetStoreName
             ], 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.get(fileName);
+            const store = transaction.objectStore(this.datasetStoreName);
+            const request = store.get(datasetId);
             request.onsuccess = (event)=>{
                 const result = event.target.result;
-                result ? resolve(result.data) : resolve(null);
+                resolve(result || null);
             };
             request.onerror = (event)=>{
                 reject(event.target.error);
             };
         });
-    listFiles = ()=>new Promise((resolve, reject)=>{
+    deleteDataset = (datasetId)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
-                this.storeName
+                this.datasetStoreName
+            ], 'readwrite');
+            const store = transaction.objectStore(this.datasetStoreName);
+            const request = store.delete(datasetId);
+            request.onsuccess = ()=>{
+                resolve();
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    listDatasets = ()=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.datasetStoreName
             ], 'readonly');
-            const store = transaction.objectStore(this.storeName);
-            const request = store.getAllKeys();
+            const store = transaction.objectStore(this.datasetStoreName);
+            const request = store.getAll();
             request.onsuccess = (event)=>{
-                const keys = event.target.result;
-                resolve(keys);
+                const result = event.target.result;
+                resolve(result);
             };
             request.onerror = (event)=>{
                 reject(event.target.error);
             };
         });
 }
+const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
+const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
+const isBase64Url = (url)=>url.startsWith('data:');
+class DataSourceBuilder {
+    type;
+    value;
+    constructor(type, value){
+        this.type = type;
+        this.value = value;
+    }
+    static from(type, value) {
+        return new DataSourceBuilder(type, value);
+    }
+    async build() {
+        const blob = await DataSourceBuilder.convertToBlob(this.type, this.value);
+        return {
+            type: this.type,
+            blob: blob
+        };
+    }
+    static async convertToBlob(type, value) {
+        if (value instanceof Blob) return value;
+        const convertCsvToBlob = (csvSource)=>{
+            if (csvSource instanceof ArrayBuffer) return new Blob([
+                csvSource
+            ], {
+                type: 'text/csv'
+            });
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DataSourceBuilder.fetchBlob(csvSource);
+            return new Blob([
+                JSON.stringify(csvSource)
+            ], {
+                type: 'text/csv'
+            });
+        };
+        const convertJsonToBlob = (jsonSource)=>{
+            if (jsonSource instanceof ArrayBuffer) return new Blob([
+                jsonSource
+            ], {
+                type: 'application/json'
+            });
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DataSourceBuilder.fetchBlob(jsonSource);
+            return new Blob([
+                JSON.stringify(jsonSource)
+            ], {
+                type: 'application/json'
+            });
+        };
+        const convertParquetToBlob = (parquetSource)=>{
+            if (parquetSource instanceof ArrayBuffer) return new Blob([
+                parquetSource
+            ], {
+                type: 'application/parquet'
+            });
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DataSourceBuilder.fetchBlob(parquetSource);
+            return new Blob([
+                parquetSource
+            ], {
+                type: 'application/parquet'
+            });
+        };
+        const convertXlsxToBlob = (xlsxSource)=>{
+            if (xlsxSource instanceof ArrayBuffer) return new Blob([
+                xlsxSource
+            ], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            });
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DataSourceBuilder.fetchBlob(xlsxSource);
+            return new Blob([
+                xlsxSource
+            ], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            });
+        };
+        switch(type){
+            case 'csv':
+                return convertCsvToBlob(value);
+            case 'json':
+                return convertJsonToBlob(value);
+            case 'xlsx':
+                return convertXlsxToBlob(value);
+            case 'parquet':
+                return convertParquetToBlob(value);
+            default:
+                return new Blob([
+                    value
+                ]);
+        }
+    }
+    static async fetchBlob(url) {
+        const response = await fetch(url);
+        return await response.blob();
+    }
+}
 class VQuery {
     duckDB;
     indexedDB;
+    isInitialized = false;
     constructor(dbName = 'vquery'){
         this.duckDB = new DuckDB();
         this.indexedDB = new IndexedDB(dbName);
     }
-    init = async ()=>{
-        await this.duckDB.init();
-        await this.indexedDB.open();
-    };
-    close = async ()=>{
+    async ensureInitialized() {
+        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 updateDataset(datasetId, data, type, datasetSchema) {
+        await this.ensureInitialized();
+        const dataSource = await DataSourceBuilder.from(type, data).build();
+        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+    }
+    async deleteDataset(datasetId) {
+        await this.ensureInitialized();
+        await this.indexedDB.deleteDataset(datasetId);
+    }
+    async listDatasets() {
+        await this.ensureInitialized();
+        return this.indexedDB.listDatasets();
+    }
+    async connectDataset(datasetId) {
+        await this.ensureInitialized();
+        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();
-        this.indexedDB.close();
-    };
-    writeFile = async (fileName, source)=>{
-        let blob;
-        if ('string' == typeof source) {
-            const response = await fetch(source);
-            blob = await response.blob();
-        } else if (source instanceof ArrayBuffer) blob = new Blob([
-            source
-        ]);
-        else if (source instanceof Uint8Array) blob = new Blob([
-            source.slice()
-        ]);
-        else if (source instanceof Blob) blob = source;
-        else throw new Error('Unsupported source type');
-        await this.indexedDB.writeFile(fileName, blob);
-        await this.duckDB.writeFile(fileName, blob);
-    };
-    readFile = async (fileName)=>{
-        const blob = await this.indexedDB.readFile(fileName);
-        if (blob) await this.duckDB.writeFile(fileName, blob);
-        else throw new Error(`File ${fileName} not found in IndexedDB`);
-    };
-    listFiles = ()=>this.indexedDB.listFiles();
-    query = async (sql)=>{
-        const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
-        const result = await this.duckDB.query(sql);
-        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
-        return {
-            ...result,
-            performance: {
-                startAt: start,
-                endAt: end,
-                duration: Number(end) - Number(start)
-            }
-        };
-    };
-    getSchema = async (fileName)=>this.duckDB.getSchema(fileName);
+    }
 }
-export { VQuery };
+export { DataSourceBuilder, VQuery, isBase64Url, isHttpUrl, isUrl };

package/dist/types/DataSet.d.ts

@@ -0,0 +1,11 @@
+export type { QueryResult } from './QueryResult';
+export type DataType = 'number' | 'string' | 'date' | 'datetime' | 'timestamp';
+export interface DatasetColumn {
+    type: DataType;
+    name: string;
+}
+export interface DatasetSchema {
+    datasetId: string;
+    datasetAlias: string;
+    columns: DatasetColumn[];
+}

package/dist/types/DataSource.d.ts

@@ -0,0 +1,7 @@
+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;
+    blob: Blob;
+}

package/dist/types/index.d.ts

@@ -1 +1,3 @@
-export type { QueryResult } from './QueryResult';
+export * from './DataSet';
+export * from './DataSource';
+export * from './QueryResult';

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export { isUrl, isHttpUrl, isBase64Url } from './url';

package/dist/utils/url.d.ts

@@ -0,0 +1,3 @@
+export declare const isUrl: (url: string) => boolean;
+export declare const isHttpUrl: (url: string) => boolean;
+export declare const isBase64Url: (url: string) => boolean;

package/dist/vquery.d.ts

@@ -1,48 +1,43 @@
-import { QueryResult } from './types';
+import { Dataset } from './dataset/dataset';
+import { DatasetSchema, TidyDatum, DataSourceType, DatasetColumn } from './types';
 export declare class VQuery {
     private duckDB;
     private indexedDB;
+    private isInitialized;
     constructor(dbName?: string);
+    private ensureInitialized;
     /**
-     * @description 初始化数据库
+     * 创建数据集，根据表结构和数据，存储信息到indexedDB
      */
-    init: () => Promise<void>;
+    createDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, datasetSchema: DatasetSchema): Promise<void>;
     /**
-     * @description 关闭数据库
+     * 修改数据集，更新信息到indexedDB内
      */
-    close: () => Promise<void>;
+    updateDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, datasetSchema: DatasetSchema): Promise<void>;
     /**
-     * @description 注册文件
-     * @param fileName 文件名
-     * @param source 文件内容
+     * 删除数据集，从indexdb移除数据集
      */
-    writeFile: (fileName: string, source: string | ArrayBuffer | Uint8Array | Blob) => Promise<void>;
+    deleteDataset(datasetId: string): Promise<void>;
     /**
-     * @description 从 IndexedDB 读取文件并注册到 DuckDB
-     * @param fileName 文件名
+     * 获取所有可用数据集
      */
-    readFile: (fileName: string) => Promise<void>;
+    listDatasets(): Promise<{
+        datasetId: string;
+        dataSource: import("./types").DataSource;
+        datasetSchema: DatasetSchema;
+    }[]>;
     /**
-     * @description 列出 IndexedDB 中的所有文件
+     * 连接数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
      */
-    listFiles: () => Promise<string[]>;
+    connectDataset(datasetId: string): Promise<Dataset>;
     /**
-     * @description 执行 SQL 查询
-     * @param sql SQL 语句
+     * 连接临时数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
+     * @param datasetId
+     * @returns
      */
-    query: (sql: string) => Promise<{
-        performance: {
-            startAt: string;
-            endAt: string;
-            duration: number;
-        };
-        dataset: any[];
-        table: any;
-    }>;
+    connectTemporaryDataset(datasetId: string, temporaryDatasetSchema?: DatasetColumn[]): Promise<Dataset>;
     /**
-     * @description 获取文件的 Schema
-     * @param fileName 文件名
-     * @returns 文件的 Schema
+     * 关闭所有数据集连接，释放DuckDB资源
      */
-    getSchema: (fileName: string) => Promise<QueryResult>;
+    close(): Promise<void>;
 }

package/package.json

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