@duckdb/duckdb-wasm 0.1.13-dev8.0 → 0.1.13

package/dist/tests-browser.js

@@ -16,21 +16,21 @@ var duckdb = (() => {
   var __commonJS = (cb, mod) => function __require2() {
     return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
-  var __reExport = (target, module2, desc) => {
-    if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-      for (let key of __getOwnPropNames(module2))
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
         if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
     }
     return target;
   };
-  var __toModule = (module2) => {
-    return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
   };
 
   // ../../node_modules/tslib/tslib.js
   var require_tslib = __commonJS({
-    "../../node_modules/tslib/tslib.js"(exports2, module2) {
+    "../../node_modules/tslib/tslib.js"(exports2, module) {
       var __extends;
       var __assign;
       var __rest;
@@ -61,8 +61,8 @@ var duckdb = (() => {
           define("tslib", ["exports"], function(exports3) {
             factory(createExporter(root, createExporter(exports3)));
           });
-        } else if (typeof module2 === "object" && typeof module2.exports === "object") {
-          factory(createExporter(root, createExporter(module2.exports)));
+        } else if (typeof module === "object" && typeof module.exports === "object") {
+          factory(createExporter(root, createExporter(module.exports)));
         } else {
           factory(createExporter(root));
         }
@@ -14621,25 +14621,6 @@ return true;`);
     }
   });
 
-  // ../../node_modules/apache-arrow/Arrow.dom.mjs
-  var import_adapters = __toModule(require_adapters());
-  var import_builder = __toModule(require_builder2());
-  var import_reader = __toModule(require_reader());
-  var import_writer = __toModule(require_writer());
-  var import_iterable = __toModule(require_iterable());
-  var import_builder2 = __toModule(require_builder3());
-  var import_reader2 = __toModule(require_reader2());
-  var import_writer2 = __toModule(require_writer2());
-  var import_Arrow = __toModule(require_Arrow());
-  import_adapters.default.toDOMStream = import_iterable.toDOMStream;
-  import_builder.Builder["throughDOM"] = import_builder2.builderThroughDOMStream;
-  import_reader.RecordBatchReader["throughDOM"] = import_reader2.recordBatchReaderThroughDOMStream;
-  import_reader.RecordBatchFileReader["throughDOM"] = import_reader2.recordBatchReaderThroughDOMStream;
-  import_reader.RecordBatchStreamReader["throughDOM"] = import_reader2.recordBatchReaderThroughDOMStream;
-  import_writer.RecordBatchWriter["throughDOM"] = import_writer2.recordBatchWriterThroughDOMStream;
-  import_writer.RecordBatchFileWriter["throughDOM"] = import_writer2.recordBatchWriterThroughDOMStream;
-  import_writer.RecordBatchStreamWriter["throughDOM"] = import_writer2.recordBatchWriterThroughDOMStream;
-
   // src/log.ts
   var LogLevel;
   (function(LogLevel2) {
@@ -14685,14 +14666,24 @@ return true;`);
     StatusCode2[StatusCode2["SUCCESS"] = 0] = "SUCCESS";
   })(StatusCode || (StatusCode = {}));
 
-  // src/utils/ipc_buffer.ts
-  var IPCBuffer = class extends import_Arrow.AsyncByteQueue {
-    flush() {
-      const buffer = super.toUint8Array(true);
-      this._values.length = 0;
-      return buffer;
-    }
-  };
+  // ../../node_modules/apache-arrow/Arrow.dom.mjs
+  var import_adapters = __toModule(require_adapters());
+  var import_builder = __toModule(require_builder2());
+  var import_reader = __toModule(require_reader());
+  var import_writer = __toModule(require_writer());
+  var import_iterable = __toModule(require_iterable());
+  var import_builder2 = __toModule(require_builder3());
+  var import_reader2 = __toModule(require_reader2());
+  var import_writer2 = __toModule(require_writer2());
+  var import_Arrow = __toModule(require_Arrow());
+  import_adapters.default.toDOMStream = import_iterable.toDOMStream;
+  import_builder.Builder["throughDOM"] = import_builder2.builderThroughDOMStream;
+  import_reader.RecordBatchReader["throughDOM"] = import_reader2.recordBatchReaderThroughDOMStream;
+  import_reader.RecordBatchFileReader["throughDOM"] = import_reader2.recordBatchReaderThroughDOMStream;
+  import_reader.RecordBatchStreamReader["throughDOM"] = import_reader2.recordBatchReaderThroughDOMStream;
+  import_writer.RecordBatchWriter["throughDOM"] = import_writer2.recordBatchWriterThroughDOMStream;
+  import_writer.RecordBatchFileWriter["throughDOM"] = import_writer2.recordBatchWriterThroughDOMStream;
+  import_writer.RecordBatchStreamWriter["throughDOM"] = import_writer2.recordBatchWriterThroughDOMStream;
 
   // src/bindings/connection.ts
   var DuckDBConnection = class {
@@ -14725,31 +14716,9 @@ return true;`);
       const stmt = this._bindings.createPrepared(this._conn, text);
       return new PreparedStatement(this._bindings, this._conn, stmt);
     }
-    insertArrowVectors(children, options) {
-      this.insertArrowTable(import_Arrow.Table.new(children), options);
-    }
     insertArrowTable(table, options) {
-      if (table.schema.fields.length == 0) {
-        console.warn("The schema is empty! If you used arrow.Table.from, consider constructing schema and batches manually");
-      }
-      this.insertArrowBatches(table.schema, table.chunks, options);
-    }
-    insertArrowBatches(schema, batches, options) {
-      if (schema.fields.length == 0) {
-        console.warn("The schema is empty! If you used arrow.Table.from, consider constructing schema and batches manually");
-      }
-      const buffer = new IPCBuffer();
-      const writer = new import_Arrow.RecordBatchStreamWriter().reset(buffer, schema);
-      let first = true;
-      for (const batch of batches) {
-        if (!first) {
-          this._bindings.insertArrowFromIPCStream(this._conn, buffer.flush(), options);
-        }
-        first = false;
-        writer.write(batch);
-      }
-      writer.finish();
-      this._bindings.insertArrowFromIPCStream(this._conn, buffer.flush(), options);
+      const buffer = table.serialize("binary", true);
+      this.insertArrowFromIPCStream(buffer, options);
     }
     insertArrowFromIPCStream(buffer, options) {
       this._bindings.insertArrowFromIPCStream(this._conn, buffer, options);
@@ -15142,6 +15111,8 @@ return true;`);
       return res;
     }
     insertArrowFromIPCStream(conn, buffer, options) {
+      if (buffer.length == 0)
+        return;
       const bufferPtr = this.mod._malloc(buffer.length);
       const bufferOfs = this.mod.HEAPU8.subarray(bufferPtr, bufferPtr + buffer.length);
       bufferOfs.set(buffer);
@@ -15303,7 +15274,7 @@ return true;`);
     InsertMode2[InsertMode2["IMPORT"] = 1] = "IMPORT";
   })(InsertMode || (InsertMode = {}));
 
-  // src/bindings/duckdb_wasm.js
+  // src/bindings/duckdb.js
   var import_meta = {};
   var DuckDB = function() {
     var _scriptDir = import_meta.url;
@@ -15766,7 +15737,7 @@ return true;`);
       }
       var wasmBinaryFile;
       if (Module["locateFile"]) {
-        wasmBinaryFile = "duckdb_wasm.wasm";
+        wasmBinaryFile = "./duckdb-wasm.wasm";
         if (!isDataURI(wasmBinaryFile)) {
           wasmBinaryFile = locateFile(wasmBinaryFile);
         }
@@ -15806,7 +15777,7 @@ return true;`);
       }
       function createWasm() {
         var info = { "a": asmLibraryArg };
-        function receiveInstance(instance, module2) {
+        function receiveInstance(instance, module) {
           var exports3 = instance.exports;
           Module["asm"] = exports3;
           wasmMemory = Module["asm"]["Ae"];
@@ -20038,7 +20009,7 @@ return true;`);
       return DuckDB3.ready;
     };
   }();
-  var duckdb_wasm_default = DuckDB;
+  var duckdb_default = DuckDB;
 
   // src/bindings/bindings_browser_base.ts
   var DuckDBBrowserBindings = class extends DuckDBBindingsBase {
@@ -20082,7 +20053,7 @@ return true;`);
       super(logger, runtime, mainModuleURL, pthreadWorkerURL);
     }
     instantiateImpl(moduleOverrides) {
-      return duckdb_wasm_default({
+      return duckdb_default({
         ...moduleOverrides,
         instantiateWasm: this.instantiateWasm.bind(this),
         locateFile: this.locateFile.bind(this)
@@ -20404,28 +20375,9 @@ return true;`);
       const stmt = await this._bindings.createPrepared(this._conn, text);
       return new AsyncPreparedStatement(this._bindings, this._conn, stmt);
     }
-    async insertArrowVectors(children, options) {
-      await this.insertArrowTable(import_Arrow.Table.new(children), options);
-    }
     async insertArrowTable(table, options) {
-      if (table.schema.fields.length == 0) {
-        console.warn("The schema is empty! If you used arrow.Table.from, consider constructing schema and batches manually");
-      }
-      await this.insertArrowBatches(table.schema, table.chunks, options);
-    }
-    async insertArrowBatches(schema, batches, options) {
-      const buffer = new IPCBuffer();
-      const writer = new import_Arrow.RecordBatchStreamWriter().reset(buffer, schema);
-      let first = true;
-      for (const batch of batches) {
-        if (!first) {
-          await this._bindings.insertArrowFromIPCStream(this._conn, buffer.flush(), options);
-        }
-        first = false;
-        writer.write(batch);
-      }
-      writer.finish();
-      await this._bindings.insertArrowFromIPCStream(this._conn, buffer.flush(), options);
+      const buffer = table.serialize("binary", true);
+      await this.insertArrowFromIPCStream(buffer, options);
     }
     async insertArrowFromIPCStream(buffer, options) {
       await this._bindings.insertArrowFromIPCStream(this._conn, buffer, options);
@@ -20891,6 +20843,8 @@ return true;`);
       await this.postTask(task);
     }
     async insertArrowFromIPCStream(conn, buffer, options) {
+      if (buffer.length == 0)
+        return;
       const task = new WorkerTask(WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [conn, buffer, options]);
       await this.postTask(task, [buffer.buffer]);
     }
@@ -20936,19 +20890,36 @@ return true;`);
 
   // package.json
   var name = "@duckdb/duckdb-wasm";
-  var version = "0.1.13-dev8.0";
+  var version = "0.1.13";
   var description = "DuckDB powered by WebAssembly";
   var license = "MPL-2.0";
   var repository = {
     type: "git",
     url: "https://github.com/duckdb/duckdb-wasm.git"
   };
+  var keywords = [
+    "sql",
+    "duckdb",
+    "relational",
+    "database",
+    "data",
+    "query",
+    "wasm",
+    "analytics",
+    "olap",
+    "arrow",
+    "parquet",
+    "json",
+    "csv"
+  ];
   var dependencies = {
     "apache-arrow": "^6.0.1",
-    "wasm-feature-detect": "^1.2.11"
+    "wasm-feature-detect": "^1.2.11",
+    "fast-glob": "^3.2.7",
+    "web-worker": "^1.2.0",
+    "@types/emscripten": "^1.39.4"
   };
   var devDependencies = {
-    "@types/emscripten": "^1.39.4",
     "@types/jasmine": "^3.10.2",
     "@typescript-eslint/eslint-plugin": "^5.4.0",
     "@typescript-eslint/parser": "^5.4.0",
@@ -20956,7 +20927,6 @@ return true;`);
     eslint: "^8.2.0",
     "eslint-plugin-jasmine": "^4.1.2",
     "eslint-plugin-react": "^7.27.0",
-    "fast-glob": "^3.2.7",
     jasmine: "^3.10.0",
     "jasmine-core": "^3.10.1",
     "jasmine-spec-reporter": "^7.0.0",
@@ -20974,8 +20944,7 @@ return true;`);
     puppeteer: "^11.0.0",
     rimraf: "^3.0.2",
     typedoc: "^0.22.9",
-    typescript: "^4.5.2",
-    "web-worker": "^1.2.0"
+    typescript: "^4.5.2"
   };
   var optionalDependencies = {
     fsevents: "*"
@@ -21002,11 +20971,11 @@ return true;`);
     "dist",
     "!dist/types/test"
   ];
-  var main_ = "./dist/duckdb-node.cjs";
-  var module = "./dist/duckdb.mjs";
-  var types = "./dist/duckdb.d.ts";
+  var main_ = "dist/duckdb-browser.mjs";
+  var types = "dist/duckdb-browser.d.ts";
+  var jsdelivr = "dist/duckdb-browser.mjs";
+  var unpkg = "dist/duckdb-browser.mjs";
   var browser = {
-    "./dist/duckdb-node.cjs": "./dist/duckdb-browser.js",
     fs: false,
     path: false,
     perf_hooks: false,
@@ -21017,63 +20986,36 @@ return true;`);
     "./dist/duckdb.wasm": "./dist/duckdb.wasm",
     "./dist/duckdb-next.wasm": "./dist/duckdb-next.wasm",
     "./dist/duckdb-next-coi.wasm": "./dist/duckdb-next-coi.wasm",
-    "./dist/duckdb-browser": "./dist/duckdb-browser.js",
-    "./dist/duckdb-browser-blocking": "./dist/duckdb-browser-blocking.js",
-    "./dist/duckdb-browser-next": "./dist/duckdb-browser-next.js",
-    "./dist/duckdb-browser-next-coi": "./dist/duckdb-browser-next-coi.js",
+    "./dist/duckdb-browser": "./dist/duckdb-browser.mjs",
+    "./dist/duckdb-browser-blocking": "./dist/duckdb-browser-blocking.mjs",
     "./dist/duckdb-browser-next-coi.pthread.worker.js": "./dist/duckdb-browser-next-coi.pthread.worker.js",
     "./dist/duckdb-browser-next-coi.worker.js": "./dist/duckdb-browser-next-coi.worker.js",
     "./dist/duckdb-browser-next.worker.js": "./dist/duckdb-browser-next.worker.js",
     "./dist/duckdb-browser.worker.js": "./dist/duckdb-browser.worker.js",
     "./dist/duckdb-node": "./dist/duckdb-node.cjs",
     "./dist/duckdb-node-blocking": "./dist/duckdb-node-blocking.cjs",
-    "./dist/duckdb-node-next": "./dist/duckdb-node-next.cjs",
-    "./dist/duckdb-node-next.worker.js": "./dist/duckdb-node-next.worker.js",
-    "./dist/duckdb-node.worker.js": "./dist/duckdb-node.worker.js",
-    "./next-coi": {
-      browser: {
-        types: "./dist/duckdb-browser-next-coi.d.ts",
-        script: "./dist/duckdb-browser-next-coi.js",
-        default: "./dist/duckdb-browser-next-coi.js"
-      }
-    },
-    "./next": {
-      browser: {
-        types: "./dist/duckdb-browser-next.d.ts",
-        script: "./dist/duckdb-browser-next.js",
-        default: "./dist/duckdb-browser-next.js"
-      },
-      node: {
-        types: "./dist/duckdb-node-next.d.ts",
-        require: "./dist/duckdb-node-next.cjs",
-        default: "./dist/duckdb-node-next.cjs"
-      }
-    },
+    "./dist/duckdb-node-next.worker.cjs": "./dist/duckdb-node-next.worker.cjs",
+    "./dist/duckdb-node.worker.cjs": "./dist/duckdb-node.worker.cjs",
     "./blocking": {
       browser: {
         types: "./dist/duckdb-browser-blocking.d.ts",
-        script: "./dist/duckdb-browser-blocking.js",
-        default: "./dist/duckdb-browser-blocking.js"
+        import: "./dist/duckdb-browser-blocking.mjs"
       },
       node: {
         types: "./dist/duckdb-node-blocking.d.ts",
         require: "./dist/duckdb-node-blocking.cjs",
-        default: "./dist/duckdb-node-blocking.cjs"
+        import: "./dist/duckdb-node-blocking.cjs"
       }
     },
     ".": {
-      types: "./dist/duckdb.d.ts",
-      import: "./dist/duckdb.mjs",
-      module: "./dist/duckdb.mjs",
       browser: {
         types: "./dist/duckdb-browser.d.ts",
-        script: "./dist/duckdb-browser.js",
-        default: "./dist/duckdb-browser.js"
+        import: "./dist/duckdb-browser.mjs"
       },
       node: {
         types: "./dist/duckdb-node.d.ts",
         require: "./dist/duckdb-node.cjs",
-        default: "./dist/duckdb-node.cjs"
+        import: "./dist/duckdb-node.cjs"
       }
     }
   };
@@ -21083,14 +21025,16 @@ return true;`);
     description,
     license,
     repository,
+    keywords,
     dependencies,
     devDependencies,
     optionalDependencies,
     scripts,
     files,
     "main:": main_,
-    module,
     types,
+    jsdelivr,
+    unpkg,
     browser,
     exports
   };
@@ -22155,32 +22099,6 @@ return true;`);
   }
 
   // test/insert_arrow.test.ts
-  function generateXInt32(n, cols) {
-    const columns = [];
-    for (let j = 0; j < cols; ++j) {
-      const column = [];
-      for (let i = 0; i < n; ++i) {
-        column.push(i);
-      }
-      columns.push(column);
-    }
-    return columns;
-  }
-  function generateArrowXInt32(n, cols) {
-    const columns = generateXInt32(n, cols);
-    const fields = [];
-    for (let j = 0; j < cols; ++j) {
-      fields.push(new import_Arrow.Field(`v${j}`, new import_Arrow.Int32()));
-    }
-    const schema = new import_Arrow.Schema(fields);
-    const batches = [];
-    for (let i = 0; i < n; ) {
-      const rows = Math.min(1e3, n - i);
-      batches.push(new import_Arrow.RecordBatch(schema, rows, columns.map((c) => import_Arrow.Int32Vector.from(c.slice(i, i + n)))));
-      i += rows;
-    }
-    return [schema, batches];
-  }
   var ARROW_INSERT_TESTS = [
     {
       name: "integers_1",
@@ -22290,42 +22208,13 @@ return true;`);
       for (const test of ARROW_INSERT_TESTS) {
         it(test.name, () => {
           conn.query(`DROP TABLE IF EXISTS ${test.options.schema || "main"}.${test.options.name}`);
-          conn.insertArrowBatches(test.schema, test.batches.map((b) => new import_Arrow.RecordBatch(test.schema, b.numRows, b.columns)), test.options);
+          const table = new import_Arrow.Table(test.schema, test.batches.map((b) => new import_Arrow.RecordBatch(test.schema, b.numRows, b.columns)));
+          conn.insertArrowTable(table, test.options);
           const results = conn.query(test.query);
           compareTable(results, test.expectedColumns);
         });
       }
     });
-    describe("Arrow insert from vectors", () => {
-      it("simple integers", () => {
-        conn.query(`DROP TABLE IF EXISTS insert_from_vectors`);
-        conn.insertArrowVectors({
-          a: import_Arrow.Int32Vector.from([1, 4, 7]),
-          b: import_Arrow.Int32Vector.from([2, 5, 8]),
-          c: import_Arrow.Utf8Vector.from(["3", "6", "9"])
-        }, {
-          name: "insert_from_vectors"
-        });
-        const results = conn.query("select * from insert_from_vectors");
-        compareTable(results, [
-          { name: "a", values: [1, 4, 7] },
-          { name: "b", values: [2, 5, 8] },
-          { name: "c", values: ["3", "6", "9"] }
-        ]);
-        conn.query(`DROP TABLE IF EXISTS insert_from_vectors`);
-      });
-    });
-    describe("Arrow benchmark inserts", () => {
-      it("generated integer batches", () => {
-        conn.query(`DROP TABLE IF EXISTS insert_generated_batches`);
-        const [schema, batches] = generateArrowXInt32(1e4, 2);
-        conn.insertArrowBatches(schema, batches, {
-          schema: "main",
-          name: "insert_generated_batches"
-        });
-        conn.query(`DROP TABLE IF EXISTS insert_generated_batches`);
-      });
-    });
   }
   function testArrowInsertAsync(db2) {
     let conn;
@@ -22338,24 +22227,26 @@ return true;`);
       await db2().flushFiles();
       await db2().dropFiles();
     });
-    describe("Arrow insert from iterable", () => {
+    describe("Arrow async insert from iterable", () => {
       for (const test of ARROW_INSERT_TESTS) {
         it(test.name, async () => {
           await conn.query(`DROP TABLE IF EXISTS ${test.options.schema || "main"}.${test.options.name}`);
-          await conn.insertArrowBatches(test.schema, test.batches.map((b) => new import_Arrow.RecordBatch(test.schema, b.numRows, b.columns)), test.options);
+          const table = new import_Arrow.Table(test.schema, test.batches.map((b) => new import_Arrow.RecordBatch(test.schema, b.numRows, b.columns)));
+          await conn.insertArrowTable(table, test.options);
           const results = await conn.query(test.query);
           compareTable(results, test.expectedColumns);
         });
       }
     });
-    describe("Arrow insert from vectors", () => {
+    describe("Arrow async insert from table", () => {
       it("simple integers", async () => {
-        await conn.query(`DROP TABLE IF EXISTS insert_from_vectors`);
-        await conn.insertArrowVectors({
-          a: import_Arrow.Int32Vector.from([1, 4, 7]),
-          b: import_Arrow.Int32Vector.from([2, 5, 8]),
-          c: import_Arrow.Utf8Vector.from(["3", "6", "9"])
-        }, {
+        await conn.query(`DROP TABLE IF EXISTS insert_from_table`);
+        const table = import_Arrow.Table.new([
+          import_Arrow.Int32Vector.from([1, 4, 7]),
+          import_Arrow.Int32Vector.from([2, 5, 8]),
+          import_Arrow.Utf8Vector.from(["3", "6", "9"])
+        ], ["a", "b", "c"]);
+        await conn.insertArrowTable(table, {
           name: "insert_from_vectors"
         });
         const results = await conn.query("select * from insert_from_vectors");