@visactor/vquery 0.1.49 → 0.1.51

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

@@ -1,11 +1,11 @@
-import { DataSourceType, DataSourceValue } from '../types';
-export declare class DataSourceBuilder {
+import { DatasetSourceType, RawDatasetSource } from '../types';
+export declare class DatasetSourceBuilder {
     private type;
     private value;
-    constructor(type: DataSourceType, value: DataSourceValue);
-    static from(type: DataSourceType, value: DataSourceValue): DataSourceBuilder;
+    constructor(raw: RawDatasetSource);
+    static from(raw: RawDatasetSource): DatasetSourceBuilder;
     build(): Promise<{
-        type: DataSourceType;
+        type: DatasetSourceType;
         blob: Blob;
     }>;
     /**

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

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

package/dist/dataset/dataset.d.ts

@@ -1,4 +1,4 @@
-import { DatasetColumn, QueryDSL } from '../types';
+import { DatasetColumn, DatasetSource, QueryDSL } from '../types';
 import { DuckDB } from '../db/duckDb';
 import { IndexedDB } from '../db/indexedDb';
 export declare class Dataset {
@@ -6,8 +6,9 @@ export declare class Dataset {
     private indexedDB;
     private _datasetId;
     constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
-    init(temporaryColumns?: DatasetColumn[]): Promise<void>;
-    queryBySQL(sql: string): Promise<{
+    init(temporaryColumns?: DatasetColumn[], temporaryDatasetSource?: DatasetSource): Promise<void>;
+    createOrReplaceView(columns: DatasetColumn[], datasetSource: DatasetSource): Promise<void>;
+    query<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): Promise<{
         performance: {
             startAt: string;
             endAt: string;
@@ -16,8 +17,7 @@ export declare class Dataset {
         dataset: any[];
         table: any;
     }>;
-    convertDSLToSQL<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): string;
-    query<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): Promise<{
+    queryBySQL(sql: string): Promise<{
         performance: {
             startAt: string;
             endAt: string;

package/dist/db/indexedDb.d.ts

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

package/dist/index.cjs

@@ -27,7 +27,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    DataSourceBuilder: ()=>DataSourceBuilder,
+    DatasetSourceBuilder: ()=>DatasetSourceBuilder,
     isHttpUrl: ()=>isHttpUrl,
     convertDSLToSQL: ()=>convertDSLToSQL,
     isBase64Url: ()=>isBase64Url,
@@ -185,7 +185,14 @@ class Dataset {
         this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
     }
-    async init(temporaryColumns = []) {
+    async init(temporaryColumns, temporaryDatasetSource) {
+        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
+        const columns = temporaryColumns ? temporaryColumns : datasetInfo.datasetSchema.columns;
+        const datasetSource = temporaryDatasetSource || datasetInfo.datasetSource;
+        if (columns.length > 0 && datasetSource) await this.createOrReplaceView(columns, datasetSource);
+    }
+    async createOrReplaceView(columns, datasetSource) {
         const readFunctionMap = {
             csv: 'read_csv_auto',
             json: 'read_json_auto',
@@ -199,18 +206,19 @@ class Dataset {
             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 = 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);
-        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);
+        if (datasetSource) {
+            const readFunction = readFunctionMap[datasetSource.type];
+            if (!readFunction) throw new Error(`Unsupported dataSource type: ${datasetSource.type}`);
+            await this.duckDB.writeFile(this._datasetId, datasetSource.blob);
+            const columnsStruct = `{${columns.map((c)=>`'${c.name}': '${dataTypeMap[c.type] || 'VARCHAR'}'`).join(', ')}}`;
+            const columnNames = columns.map((c)=>`"${c.name}"`).join(', ');
+            const createViewSql = `CREATE OR REPLACE VIEW "${this._datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${this._datasetId}', columns=${columnsStruct})`;
+            await this.duckDB.query(createViewSql);
+        }
+    }
+    async query(queryDSL) {
+        const sql = convertDSLToSQL(queryDSL, this.datasetId);
+        return this.queryBySQL(sql);
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
@@ -225,13 +233,6 @@ 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}"`);
     }
@@ -331,7 +332,7 @@ class IndexedDB {
             this.db = null;
         }
     };
-    writeDataset = (datasetId, dataSource, datasetSchema)=>new Promise((resolve, reject)=>{
+    writeDataset = (datasetId, datasetSchema, datasetSource)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
                 this.datasetStoreName
@@ -339,8 +340,8 @@ class IndexedDB {
             const store = transaction.objectStore(this.datasetStoreName);
             const request = store.put({
                 datasetId,
-                dataSource,
-                datasetSchema
+                datasetSchema,
+                datasetSource
             });
             request.onsuccess = ()=>{
                 resolve();
@@ -397,18 +398,18 @@ class IndexedDB {
 const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
 const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
 const isBase64Url = (url)=>url.startsWith('data:');
-class DataSourceBuilder {
+class DatasetSourceBuilder {
     type;
     value;
-    constructor(type, value){
-        this.type = type;
-        this.value = value;
+    constructor(raw){
+        this.type = raw.type;
+        this.value = raw.rawDataset;
     }
-    static from(type, value) {
-        return new DataSourceBuilder(type, value);
+    static from(raw) {
+        return new DatasetSourceBuilder(raw);
     }
     async build() {
-        const blob = await DataSourceBuilder.convertToBlob(this.type, this.value);
+        const blob = await DatasetSourceBuilder.convertToBlob(this.type, this.value);
         return {
             type: this.type,
             blob: blob
@@ -422,7 +423,7 @@ class DataSourceBuilder {
             ], {
                 type: 'text/csv'
             });
-            if ('string' == typeof csvSource && isUrl(csvSource)) return DataSourceBuilder.fetchBlob(csvSource);
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DatasetSourceBuilder.fetchBlob(csvSource);
             return new Blob([
                 JSON.stringify(csvSource)
             ], {
@@ -435,7 +436,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/json'
             });
-            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DataSourceBuilder.fetchBlob(jsonSource);
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DatasetSourceBuilder.fetchBlob(jsonSource);
             return new Blob([
                 JSON.stringify(jsonSource)
             ], {
@@ -448,7 +449,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/parquet'
             });
-            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DataSourceBuilder.fetchBlob(parquetSource);
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DatasetSourceBuilder.fetchBlob(parquetSource);
             return new Blob([
                 parquetSource
             ], {
@@ -461,7 +462,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
             });
-            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DataSourceBuilder.fetchBlob(xlsxSource);
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DatasetSourceBuilder.fetchBlob(xlsxSource);
             return new Blob([
                 xlsxSource
             ], {
@@ -496,60 +497,73 @@ class VQuery {
         this.duckDB = new DuckDB();
         this.indexedDB = new IndexedDB(dbName);
     }
-    async ensureInitialized() {
+    async checkInitialized() {
         if (!this.isInitialized) {
             await this.duckDB.init();
             await this.indexedDB.open();
             this.isInitialized = true;
         }
     }
-    async createDataset(datasetId, data, type, columns = []) {
-        await this.ensureInitialized();
-        const dataSource = await DataSourceBuilder.from(type, data).build();
+    async checkDatasetExists(datasetId) {
+        if (!await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} not exists, please create it first`);
+    }
+    async createDataset(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        if (await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} already exists`);
         const datasetSchema = {
             datasetId,
             datasetAlias: datasetId,
             columns: columns
         };
-        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
-    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 updateDatasetSource(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
     async dropDataset(datasetId) {
-        await this.ensureInitialized();
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
         await this.indexedDB.deleteDataset(datasetId);
     }
+    async connectDataset(datasetId, temporaryColumns, temporaryRawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        const temporaryDatasetSource = temporaryRawDatasetSource ? await DatasetSourceBuilder.from(temporaryRawDatasetSource).build() : void 0;
+        await dataset.init(temporaryColumns, temporaryDatasetSource);
+        return dataset;
+    }
     async hasDataset(datasetId) {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         const datasets = await this.indexedDB.listDatasets();
         return datasets.some((item)=>item.datasetId === datasetId);
     }
     async listDatasets() {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         return this.indexedDB.listDatasets();
     }
-    async connectDataset(datasetId, temporaryColumns = []) {
-        await this.ensureInitialized();
-        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init(temporaryColumns);
-        return dataset;
-    }
     async close() {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         await this.duckDB.close();
     }
 }
-exports.DataSourceBuilder = __webpack_exports__.DataSourceBuilder;
+exports.DatasetSourceBuilder = __webpack_exports__.DatasetSourceBuilder;
 exports.VQuery = __webpack_exports__.VQuery;
 exports.convertDSLToSQL = __webpack_exports__.convertDSLToSQL;
 exports.isBase64Url = __webpack_exports__.isBase64Url;
 exports.isHttpUrl = __webpack_exports__.isHttpUrl;
 exports.isUrl = __webpack_exports__.isUrl;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "DataSourceBuilder",
+    "DatasetSourceBuilder",
     "VQuery",
     "convertDSLToSQL",
     "isBase64Url",

package/dist/index.d.ts

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

package/dist/index.js

@@ -150,7 +150,14 @@ class Dataset {
         this.indexedDB = indexedDB1;
         this._datasetId = datasetId;
     }
-    async init(temporaryColumns = []) {
+    async init(temporaryColumns, temporaryDatasetSource) {
+        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
+        const columns = temporaryColumns ? temporaryColumns : datasetInfo.datasetSchema.columns;
+        const datasetSource = temporaryDatasetSource || datasetInfo.datasetSource;
+        if (columns.length > 0 && datasetSource) await this.createOrReplaceView(columns, datasetSource);
+    }
+    async createOrReplaceView(columns, datasetSource) {
         const readFunctionMap = {
             csv: 'read_csv_auto',
             json: 'read_json_auto',
@@ -164,18 +171,19 @@ class Dataset {
             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 = 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);
-        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);
+        if (datasetSource) {
+            const readFunction = readFunctionMap[datasetSource.type];
+            if (!readFunction) throw new Error(`Unsupported dataSource type: ${datasetSource.type}`);
+            await this.duckDB.writeFile(this._datasetId, datasetSource.blob);
+            const columnsStruct = `{${columns.map((c)=>`'${c.name}': '${dataTypeMap[c.type] || 'VARCHAR'}'`).join(', ')}}`;
+            const columnNames = columns.map((c)=>`"${c.name}"`).join(', ');
+            const createViewSql = `CREATE OR REPLACE VIEW "${this._datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${this._datasetId}', columns=${columnsStruct})`;
+            await this.duckDB.query(createViewSql);
+        }
+    }
+    async query(queryDSL) {
+        const sql = convertDSLToSQL(queryDSL, this.datasetId);
+        return this.queryBySQL(sql);
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
@@ -190,13 +198,6 @@ 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}"`);
     }
@@ -295,7 +296,7 @@ class IndexedDB {
             this.db = null;
         }
     };
-    writeDataset = (datasetId, dataSource, datasetSchema)=>new Promise((resolve, reject)=>{
+    writeDataset = (datasetId, datasetSchema, datasetSource)=>new Promise((resolve, reject)=>{
             if (!this.db) return reject('DB is not open');
             const transaction = this.db.transaction([
                 this.datasetStoreName
@@ -303,8 +304,8 @@ class IndexedDB {
             const store = transaction.objectStore(this.datasetStoreName);
             const request = store.put({
                 datasetId,
-                dataSource,
-                datasetSchema
+                datasetSchema,
+                datasetSource
             });
             request.onsuccess = ()=>{
                 resolve();
@@ -361,18 +362,18 @@ class IndexedDB {
 const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
 const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
 const isBase64Url = (url)=>url.startsWith('data:');
-class DataSourceBuilder {
+class DatasetSourceBuilder {
     type;
     value;
-    constructor(type, value){
-        this.type = type;
-        this.value = value;
+    constructor(raw){
+        this.type = raw.type;
+        this.value = raw.rawDataset;
     }
-    static from(type, value) {
-        return new DataSourceBuilder(type, value);
+    static from(raw) {
+        return new DatasetSourceBuilder(raw);
     }
     async build() {
-        const blob = await DataSourceBuilder.convertToBlob(this.type, this.value);
+        const blob = await DatasetSourceBuilder.convertToBlob(this.type, this.value);
         return {
             type: this.type,
             blob: blob
@@ -386,7 +387,7 @@ class DataSourceBuilder {
             ], {
                 type: 'text/csv'
             });
-            if ('string' == typeof csvSource && isUrl(csvSource)) return DataSourceBuilder.fetchBlob(csvSource);
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DatasetSourceBuilder.fetchBlob(csvSource);
             return new Blob([
                 JSON.stringify(csvSource)
             ], {
@@ -399,7 +400,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/json'
             });
-            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DataSourceBuilder.fetchBlob(jsonSource);
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DatasetSourceBuilder.fetchBlob(jsonSource);
             return new Blob([
                 JSON.stringify(jsonSource)
             ], {
@@ -412,7 +413,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/parquet'
             });
-            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DataSourceBuilder.fetchBlob(parquetSource);
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DatasetSourceBuilder.fetchBlob(parquetSource);
             return new Blob([
                 parquetSource
             ], {
@@ -425,7 +426,7 @@ class DataSourceBuilder {
             ], {
                 type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
             });
-            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DataSourceBuilder.fetchBlob(xlsxSource);
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DatasetSourceBuilder.fetchBlob(xlsxSource);
             return new Blob([
                 xlsxSource
             ], {
@@ -460,50 +461,63 @@ class VQuery {
         this.duckDB = new DuckDB();
         this.indexedDB = new IndexedDB(dbName);
     }
-    async ensureInitialized() {
+    async checkInitialized() {
         if (!this.isInitialized) {
             await this.duckDB.init();
             await this.indexedDB.open();
             this.isInitialized = true;
         }
     }
-    async createDataset(datasetId, data, type, columns = []) {
-        await this.ensureInitialized();
-        const dataSource = await DataSourceBuilder.from(type, data).build();
+    async checkDatasetExists(datasetId) {
+        if (!await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} not exists, please create it first`);
+    }
+    async createDataset(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        if (await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} already exists`);
         const datasetSchema = {
             datasetId,
             datasetAlias: datasetId,
             columns: columns
         };
-        await this.indexedDB.writeDataset(datasetId, dataSource, datasetSchema);
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
-    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 updateDatasetSource(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
     }
     async dropDataset(datasetId) {
-        await this.ensureInitialized();
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
         await this.indexedDB.deleteDataset(datasetId);
     }
+    async connectDataset(datasetId, temporaryColumns, temporaryRawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        const temporaryDatasetSource = temporaryRawDatasetSource ? await DatasetSourceBuilder.from(temporaryRawDatasetSource).build() : void 0;
+        await dataset.init(temporaryColumns, temporaryDatasetSource);
+        return dataset;
+    }
     async hasDataset(datasetId) {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         const datasets = await this.indexedDB.listDatasets();
         return datasets.some((item)=>item.datasetId === datasetId);
     }
     async listDatasets() {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         return this.indexedDB.listDatasets();
     }
-    async connectDataset(datasetId, temporaryColumns = []) {
-        await this.ensureInitialized();
-        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
-        await dataset.init(temporaryColumns);
-        return dataset;
-    }
     async close() {
-        await this.ensureInitialized();
+        await this.checkInitialized();
         await this.duckDB.close();
     }
 }
-export { DataSourceBuilder, VQuery, convertDSLToSQL, isBase64Url, isHttpUrl, isUrl };
+export { DatasetSourceBuilder, VQuery, convertDSLToSQL, isBase64Url, isHttpUrl, isUrl };

package/dist/types/DataSource.d.ts

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

package/dist/vquery.d.ts

@@ -1,41 +1,21 @@
 import { Dataset } from './dataset/dataset';
-import { DatasetSchema, TidyDatum, DataSourceType, DatasetColumn } from './types';
+import { RawDatasetSource, DatasetColumn } from './types';
 export declare class VQuery {
     private duckDB;
     private indexedDB;
     private isInitialized;
     constructor(dbName?: string);
-    private ensureInitialized;
-    /**
-     * 创建数据集，根据表结构和数据，存储信息到indexedDB
-     */
-    createDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, columns?: DatasetColumn[]): Promise<void>;
-    /**
-     * 修改数据集，更新信息到indexedDB内
-     */
-    updateDataset(datasetId: string, data: string | ArrayBuffer | Blob | TidyDatum[], type: DataSourceType, datasetSchema: DatasetSchema): Promise<void>;
-    /**
-     * 删除数据集，从indexdb移除数据集
-     */
+    private checkInitialized;
+    private checkDatasetExists;
+    createDataset(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
+    updateDatasetSource(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
     dropDataset(datasetId: string): Promise<void>;
-    /**
-     * 检查数据集是否存在
-     */
+    connectDataset(datasetId: string, temporaryColumns?: DatasetColumn[], temporaryRawDatasetSource?: RawDatasetSource): Promise<Dataset>;
     hasDataset(datasetId: string): Promise<boolean>;
-    /**
-     * 获取所有可用数据集
-     */
     listDatasets(): Promise<{
         datasetId: string;
-        dataSource: import("./types").DataSource;
-        datasetSchema: DatasetSchema;
+        dataSource?: import("./types").DatasetSource;
+        datasetSchema: import("./types").DatasetSchema;
     }[]>;
-    /**
-     * 连接数据集，返回数据集信息，从indexedDB获取表结构，使用DuckDB在内存中创建表
-     */
-    connectDataset(datasetId: string, temporaryColumns?: DatasetColumn[]): Promise<Dataset>;
-    /**
-     * 关闭所有数据集连接，释放DuckDB资源
-     */
     close(): Promise<void>;
 }

package/package.json

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