@duckdb/duckdb-wasm 0.1.13-dev21.0 → 0.1.13-dev29.0

package/dist/tests-browser.js

@@ -14716,23 +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 writer = import_Arrow.RecordBatchStreamWriter.writeAll(batches);
-      writer.finish();
-      const materialized = writer.toUint8Array(true);
-      this._bindings.insertArrowFromIPCStream(this._conn, materialized, options);
+      const buffer = table.serialize("binary", true);
+      this.insertArrowFromIPCStream(buffer, options);
     }
     insertArrowFromIPCStream(buffer, options) {
       this._bindings.insertArrowFromIPCStream(this._conn, buffer, options);
@@ -15288,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;
@@ -15751,7 +15737,7 @@ return true;`);
       }
       var wasmBinaryFile;
       if (Module["locateFile"]) {
-        wasmBinaryFile = "duckdb_wasm.wasm";
+        wasmBinaryFile = "./duckdb-wasm.wasm";
         if (!isDataURI(wasmBinaryFile)) {
           wasmBinaryFile = locateFile(wasmBinaryFile);
         }
@@ -20023,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 {
@@ -20067,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)
@@ -20389,20 +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 writer = import_Arrow.RecordBatchStreamWriter.writeAll(batches);
-      writer.finish();
-      const materialized = writer.toUint8Array(true);
-      await this._bindings.insertArrowFromIPCStream(this._conn, materialized, options);
+      const buffer = table.serialize("binary", true);
+      await this.insertArrowFromIPCStream(buffer, options);
     }
     async insertArrowFromIPCStream(buffer, options) {
       await this._bindings.insertArrowFromIPCStream(this._conn, buffer, options);
@@ -20915,7 +20890,7 @@ return true;`);
 
   // package.json
   var name = "@duckdb/duckdb-wasm";
-  var version = "0.1.13-dev21.0";
+  var version = "0.1.13-dev29.0";
   var description = "DuckDB powered by WebAssembly";
   var license = "MPL-2.0";
   var repository = {
@@ -20981,15 +20956,15 @@ return true;`);
     "dist",
     "!dist/types/test"
   ];
-  var main_ = "./dist/duckdb-node.cjs";
-  var module = "./dist/duckdb-node.mjs";
-  var types = "./dist/duckdb-node.d.ts";
-  var jsdelivr_ = "./dist/duckdb-browser.js";
-  var unpkg_ = "./dist/duckdb-browser.js";
+  var main_ = "dist/duckdb-node.cjs";
+  var module = "dist/duckdb-node.mjs";
+  var types = "dist/duckdb-node.d.ts";
+  var jsdelivr_ = "dist/duckdb-browser.js";
+  var unpkg_ = "dist/duckdb-browser.js";
   var browser = {
-    "./dist/duckdb-node.cjs": "./dist/duckdb-browser.js",
-    "./dist/duckdb-node.mjs": "./dist/duckdb-browser.mjs",
-    "./dist/duckdb-node.d.ts": "./dist/duckdb-browser.d.ts",
+    "dist/duckdb-node.cjs": "dist/duckdb-browser.js",
+    "dist/duckdb-node.mjs": "dist/duckdb-browser.mjs",
+    "dist/duckdb-node.d.ts": "dist/duckdb-browser.d.ts",
     fs: false,
     path: false,
     perf_hooks: false,
@@ -22139,32 +22114,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",
@@ -22274,42 +22223,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;
@@ -22326,30 +22246,13 @@ return true;`);
       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 async insert from vectors", () => {
-      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"])
-        }, {
-          name: "insert_from_vectors"
-        });
-        const results = await 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"] }
-        ]);
-      });
-    });
     describe("Arrow async insert from table", () => {
       it("simple integers", async () => {
         await conn.query(`DROP TABLE IF EXISTS insert_from_table`);