hyperdb-wasm 0.0.27099-dev.wasm.g0a1be56f → 0.0.27099-dev.wasm.g3764e520

package/dist/api.d.ts

@@ -72,10 +72,13 @@ export interface QueryInfo {
     readonly preExecutionMetrics: QueryMetrics | null;
     readonly executionMetrics: QueryMetrics | null;
 }
-export interface QueryResult<Result> {
-    readonly result: Result;
+export interface QueryOperation {
     readonly info: Promise<QueryInfo>;
 }
+export interface QueryPromise<Result> extends Promise<Result>, QueryOperation {
+}
+export interface QueryStreamIPC extends AsyncIterable<Uint8Array>, QueryOperation {
+}
 export declare class HyperDBError extends Error {
     readonly sqlState: string;
     readonly errorSource: HyperDBErrorSource;
@@ -110,14 +113,15 @@ export declare class HyperDBConnection {
     private closing;
     constructor(client: HyperDBClient, connection: number, onClose?: () => void);
     close(): Promise<void>;
-    sendIPC(sql: string): QueryResult<AsyncIterable<Uint8Array>>;
-    queryIPC(sql: string): QueryResult<Promise<Uint8Array>>;
-    send<T extends TypeMap = {
+    queryStreamIPC(sql: string): QueryStreamIPC;
+    queryIPC(sql: string): QueryPromise<Uint8Array>;
+    queryStream<T extends TypeMap = {
         [key: string]: DataType;
-    }>(sql: string): QueryResult<Promise<AsyncRecordBatchStreamReader<T>>>;
+    }>(sql: string): QueryPromise<AsyncRecordBatchStreamReader<T>>;
     query<T extends TypeMap = {
         [key: string]: DataType;
-    }>(sql: string): QueryResult<Promise<Table<T>>>;
+    }>(sql: string): QueryPromise<Table<T>>;
+    execute(sql: string): QueryPromise<bigint | null>;
     insertArrowTable(table: Table, options: ArrowInsertOptions): Promise<void>;
     insertArrowIPCFromPath(path: string, options: ArrowInsertOptions): Promise<void>;
     private insertArrowIPCFromPathInternal;

package/dist/browser.js

@@ -12156,8 +12156,24 @@ function deferred() {
   void promise.catch(() => void 0);
   return { promise, resolve, reject };
 }
-function queryResult(result, info) {
-  return { result, info };
+function queryPromise(result, info) {
+  return Object.assign(result, { info });
+}
+function queryIPCStream(result, info) {
+  return Object.assign(result, { info });
+}
+function affectedRowCount(info) {
+  switch (info.statementKind) {
+    case "COPY":
+    case "DELETE":
+    case "FETCH":
+    case "INSERT":
+    case "MERGE":
+    case "UPDATE":
+      return info.rowCount;
+    default:
+      return null;
+  }
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12407,7 +12423,7 @@ var HyperDBConnection = class {
     }
     await this.closing;
   }
-  sendIPC(sql) {
+  queryStreamIPC(sql) {
     const connection = this;
     const queryInfo = deferred();
     const result = (async function* () {
@@ -12475,14 +12491,14 @@ var HyperDBConnection = class {
         }
       }
     })();
-    return queryResult(result, queryInfo.promise);
+    return queryIPCStream(result, queryInfo.promise);
   }
   queryIPC(sql) {
-    const stream = this.sendIPC(sql);
+    const stream = this.queryStreamIPC(sql);
     const result = (async () => {
       const chunks = [];
       let length = 0;
-      for await (const chunk of stream.result) {
+      for await (const chunk of stream) {
         chunks.push(chunk);
         length += chunk.byteLength;
       }
@@ -12494,28 +12510,37 @@ var HyperDBConnection = class {
       }
       return bytes;
     })();
-    return queryResult(result, stream.info);
+    return queryPromise(result, stream.info);
   }
-  send(sql) {
-    const stream = this.sendIPC(sql);
+  queryStream(sql) {
+    const stream = this.queryStreamIPC(sql);
     const result = (async () => {
-      const reader = await RecordBatchReader.from(stream.result);
+      const reader = await RecordBatchReader.from(stream);
       if (!reader.isAsync() || !reader.isStream()) throw new Error("query did not produce an Arrow async stream");
       await reader.open();
       if (!reader.schema) throw new Error("query did not produce an Arrow schema");
       return reader;
     })();
-    return queryResult(result, stream.info);
+    return queryPromise(result, stream.info);
   }
   query(sql) {
-    const stream = this.send(sql);
+    const stream = this.queryStream(sql);
     const result = (async () => {
-      const reader = await stream.result;
+      const reader = await stream;
       const batches = [];
       for await (const batch of reader) batches.push(batch);
       return new Table(reader.schema, batches);
     })();
-    return queryResult(result, stream.info);
+    return queryPromise(result, stream.info);
+  }
+  execute(sql) {
+    const stream = this.queryStreamIPC(sql);
+    const result = (async () => {
+      for await (const _chunk of stream) {
+      }
+      return affectedRowCount(await stream.info);
+    })();
+    return queryPromise(result, stream.info);
   }
   async insertArrowTable(table, options) {
     this.ensureAvailable();

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { HyperDB as BaseHyperDB } from './api.js';
 import type { BrowserCreateOptions, MountAccessMode, MountedResource, MountOptions } from './api.js';
 export { HyperDBConnection, HyperDBError } from './api.js';
-export type { ArrowInsertOptions, BrowserCreateOptions, HyperDBSettingValue, HyperDBSettings, MountAccessMode, MountedResource, MountOptions, QueryInfo, QueryMetrics, QueryMetricValue, QueryResult, QueryTimings } from './api.js';
+export type { ArrowInsertOptions, BrowserCreateOptions, HyperDBSettingValue, HyperDBSettings, MountAccessMode, MountedResource, MountOptions, QueryInfo, QueryMetrics, QueryMetricValue, QueryOperation, QueryPromise, QueryStreamIPC, QueryTimings } from './api.js';
 export type { SetupProgress } from './protocol.js';
 export type { HyperDBErrorSource } from './protocol.js';
 export interface FileSystemDirectoryHandleLike {

package/dist/index.node.d.ts

@@ -2,7 +2,7 @@ import { HyperDB as BaseHyperDB } from './api.js';
 import type { HyperDBCreateOptions, MountedResource, MountOptions } from './api.js';
 import type { NodeClientOptions } from './node.js';
 export { HyperDBConnection, HyperDBError } from './api.js';
-export type { ArrowInsertOptions, HyperDBSettingValue, HyperDBSettings, MountAccessMode, MountedResource, MountOptions, QueryInfo, QueryMetrics, QueryMetricValue, QueryResult, QueryTimings } from './api.js';
+export type { ArrowInsertOptions, HyperDBSettingValue, HyperDBSettings, MountAccessMode, MountedResource, MountOptions, QueryInfo, QueryMetrics, QueryMetricValue, QueryOperation, QueryPromise, QueryStreamIPC, QueryTimings } from './api.js';
 export type { HyperDBErrorSource } from './protocol.js';
 export type NodeCreateOptions = NodeClientOptions & HyperDBCreateOptions;
 export declare class HyperDB extends BaseHyperDB {

package/dist/node.js

@@ -12325,8 +12325,24 @@ function deferred() {
   void promise.catch(() => void 0);
   return { promise, resolve, reject };
 }
-function queryResult(result, info) {
-  return { result, info };
+function queryPromise(result, info) {
+  return Object.assign(result, { info });
+}
+function queryIPCStream(result, info) {
+  return Object.assign(result, { info });
+}
+function affectedRowCount(info) {
+  switch (info.statementKind) {
+    case "COPY":
+    case "DELETE":
+    case "FETCH":
+    case "INSERT":
+    case "MERGE":
+    case "UPDATE":
+      return info.rowCount;
+    default:
+      return null;
+  }
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12576,7 +12592,7 @@ var HyperDBConnection = class {
     }
     await this.closing;
   }
-  sendIPC(sql) {
+  queryStreamIPC(sql) {
     const connection = this;
     const queryInfo = deferred();
     const result = (async function* () {
@@ -12644,14 +12660,14 @@ var HyperDBConnection = class {
         }
       }
     })();
-    return queryResult(result, queryInfo.promise);
+    return queryIPCStream(result, queryInfo.promise);
   }
   queryIPC(sql) {
-    const stream = this.sendIPC(sql);
+    const stream = this.queryStreamIPC(sql);
     const result = (async () => {
       const chunks = [];
       let length = 0;
-      for await (const chunk of stream.result) {
+      for await (const chunk of stream) {
         chunks.push(chunk);
         length += chunk.byteLength;
       }
@@ -12663,28 +12679,37 @@ var HyperDBConnection = class {
       }
       return bytes;
     })();
-    return queryResult(result, stream.info);
+    return queryPromise(result, stream.info);
   }
-  send(sql) {
-    const stream = this.sendIPC(sql);
+  queryStream(sql) {
+    const stream = this.queryStreamIPC(sql);
     const result = (async () => {
-      const reader = await RecordBatchReader.from(stream.result);
+      const reader = await RecordBatchReader.from(stream);
       if (!reader.isAsync() || !reader.isStream()) throw new Error("query did not produce an Arrow async stream");
       await reader.open();
       if (!reader.schema) throw new Error("query did not produce an Arrow schema");
       return reader;
     })();
-    return queryResult(result, stream.info);
+    return queryPromise(result, stream.info);
   }
   query(sql) {
-    const stream = this.send(sql);
+    const stream = this.queryStream(sql);
     const result = (async () => {
-      const reader = await stream.result;
+      const reader = await stream;
       const batches = [];
       for await (const batch of reader) batches.push(batch);
       return new Table(reader.schema, batches);
     })();
-    return queryResult(result, stream.info);
+    return queryPromise(result, stream.info);
+  }
+  execute(sql) {
+    const stream = this.queryStreamIPC(sql);
+    const result = (async () => {
+      for await (const _chunk of stream) {
+      }
+      return affectedRowCount(await stream.info);
+    })();
+    return queryPromise(result, stream.info);
   }
   async insertArrowTable(table, options) {
     this.ensureAvailable();

package/examples/browser-attached-databases.html

@@ -26,22 +26,22 @@
         const connection = await database.connect();
 
         try {
-            await database.createDatabase('readings');
-            await database.createDatabase(persistentName, { storage: 'persistent' });
-            await connection.attachDatabase('readings');
-            await connection.attachDatabase(persistentName, 'sensors');
+            await connection.execute('create database "readings.hyper"');
+            await connection.execute(`create database "${persistentName}.hyper"`);
+            await connection.execute('attach database "readings.hyper" as readings');
+            await connection.execute(`attach database "${persistentName}.hyper" as sensors`);
 
-            await connection.queryIPC('create table readings.public.values_table(sensor_id integer, reading integer)').result;
-            await connection.queryIPC('insert into readings.public.values_table values (101, 18), (202, 22)').result;
-            await connection.queryIPC('create table sensors.public.locations(sensor_id integer, location text)').result;
-            await connection.queryIPC("insert into sensors.public.locations values (101, 'office'), (202, 'lab')").result;
+            await connection.execute('create table readings.public.values_table(sensor_id integer, reading integer)');
+            await connection.execute('insert into readings.public.values_table values (101, 18), (202, 22)');
+            await connection.execute('create table sensors.public.locations(sensor_id integer, location text)');
+            await connection.execute("insert into sensors.public.locations values (101, 'office'), (202, 'lab')");
 
             const table = await connection.query(`
                 select locations.location, values_table.reading
                 from readings.public.values_table
                 join sensors.public.locations using (sensor_id)
                 order by locations.location
-            `).result;
+            `);
             const names = table.schema.fields.map(({ name }) => name);
             const tableElement = document.createElement('table');
             const header = tableElement.createTHead().insertRow();
@@ -59,11 +59,10 @@
             result.append(tableElement);
             status.textContent = 'Joined a memory database with a persistent database';
         } finally {
-            await connection.detachDatabase('readings');
-            await connection.detachDatabase('sensors');
+            await connection.execute('detach database readings, sensors');
+            await connection.execute('drop database "readings.hyper"');
+            await connection.execute(`drop database "${persistentName}.hyper"`);
             await connection.close();
-            await database.dropDatabase('readings');
-            await database.dropDatabase(persistentName);
             await database.terminate();
         }
     </script>

package/examples/browser.html

@@ -65,7 +65,7 @@ order by sensor_id</textarea>
             run.disabled = true;
             status.textContent = 'Running...';
             try {
-                const table = await connection.query(sql.value).result;
+                const table = await connection.query(sql.value);
                 render(table);
                 status.textContent = `${table.numRows} row(s)`;
             } catch (error) {

package/examples/node-attached-databases.mjs

@@ -8,30 +8,30 @@ const database = await HyperDB.create({ storagePath });
 const connection = await database.connect();
 
 try {
-    await connection.queryIPC('create database "readings.hyper"').result;
-    await connection.queryIPC('create database "sensors.hyper"').result;
-    await connection.queryIPC('attach database "readings.hyper" as readings').result;
-    await connection.queryIPC('attach database "sensors.hyper" as sensors').result;
+    await connection.execute('create database "readings.hyper"');
+    await connection.execute('create database "sensors.hyper"');
+    await connection.execute('attach database "readings.hyper" as readings');
+    await connection.execute('attach database "sensors.hyper" as sensors');
 
-    await connection.queryIPC('create table readings.public.values_table(sensor_id integer, reading integer)').result;
-    await connection.queryIPC('create table sensors.public.locations(sensor_id integer, location text)').result;
-    await connection.queryIPC('begin').result;
-    await connection.queryIPC('insert into readings.public.values_table values (101, 18), (202, 22)').result;
-    await connection.queryIPC("insert into sensors.public.locations values (101, 'office'), (202, 'lab')").result;
+    await connection.execute('create table readings.public.values_table(sensor_id integer, reading integer)');
+    await connection.execute('create table sensors.public.locations(sensor_id integer, location text)');
+    await connection.execute('begin');
+    await connection.execute('insert into readings.public.values_table values (101, 18), (202, 22)');
+    await connection.execute("insert into sensors.public.locations values (101, 'office'), (202, 'lab')");
 
     const result = await connection.query(`
         select locations.location, values_table.reading
         from readings.public.values_table
         join sensors.public.locations using (sensor_id)
         order by locations.location
-    `).result;
+    `);
     console.table(result.toArray().map((row) => row.toJSON()));
 } finally {
-    await connection.queryIPC('commit').result;
-    await connection.queryIPC('detach database readings, sensors').result;
+    await connection.execute('commit');
+    await connection.execute('detach database readings, sensors');
+    await connection.execute('drop database "readings.hyper"');
+    await connection.execute('drop database "sensors.hyper"');
     await connection.close();
-    await connection.queryIPC('drop database "readings.hyper"').result;
-    await connection.queryIPC('drop database "sensors.hyper"').result;
     await database.terminate();
     await rm(storagePath, { recursive: true, force: true });
 }

package/examples/node.mjs

@@ -20,7 +20,7 @@ try {
         select
             6 * 7 as answer,
             upper('query Hyper from Node.js') as message
-    `).result;
+    `);
     console.table(rows(expressions));
 
     const grouped = await connection.query(`
@@ -32,14 +32,14 @@ try {
         ) as readings(sensor_id, reading)
         group by sensor_id
         order by sensor_id
-    `).result;
+    `);
     console.table(rows(grouped));
 
-    const reader = await connection.send(`
+    const reader = await connection.queryStream(`
         select value, value * value as square
         from generate_series(1, 5) as numbers(value)
         order by value
-    `).result;
+    `);
     for await (const batch of reader) {
         console.log(`streamed Arrow batch with ${batch.numRows} rows`);
     }
@@ -59,9 +59,9 @@ try {
     await connection.insertArrowIPCFromPath(readingsPath, { name: 'temporary_readings' });
 
     console.log('Arrow IPC staged in the in-memory WasmFS:');
-    console.table(rows(await connection.query('select * from memory_readings order by sensor_id').result));
+    console.table(rows(await connection.query('select * from memory_readings order by sensor_id')));
     console.log(`Arrow IPC read from the Node temporary file ${readingsPath}:`);
-    console.table(rows(await connection.query('select * from temporary_readings order by sensor_id').result));
+    console.table(rows(await connection.query('select * from temporary_readings order by sensor_id')));
 } finally {
     await connection.close();
     await database.terminate();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hyperdb-wasm",
-    "version": "0.0.27099-dev.wasm.g0a1be56f",
+    "version": "0.0.27099-dev.wasm.g3764e520",
     "type": "module",
     "engines": {
         "node": ">=24"