picovolt 0.12.0 → 1.1.0

package/README.md

@@ -1,14 +1,15 @@
 # PicoVolt (PVDB)
 
 [![CI](https://github.com/MiniJe/picovolt/actions/workflows/ci.yml/badge.svg)](https://github.com/MiniJe/picovolt/actions/workflows/ci.yml)
-[![Version](https://img.shields.io/badge/version-0.12.0-blue.svg)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-1.1.0-blue.svg)](CHANGELOG.md)
 [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
-![Status: experimental](https://img.shields.io/badge/status-experimental-orange.svg)
+![Status: 1.0 stable](https://img.shields.io/badge/status-1.0%20stable-brightgreen.svg)
 [![GitHub stars](https://img.shields.io/github/stars/MiniJe/picovolt?style=social)](https://github.com/MiniJe/picovolt)
 
-PicoVolt is an embedded database engine written from scratch in Rust. It is
-experimental software. It has not been audited or hardened for production, so use
-it to learn from and prototype with rather than to store data you cannot lose.
+PicoVolt is an embedded database engine written from scratch in Rust. As of 1.0
+its public API and on-disk format are stable under Semantic Versioning. It is
+young software and has not had an external security audit, so review it and keep
+backups before trusting it with data you cannot regenerate.
 
 If PicoVolt is useful to you, consider starring the repository on GitHub. It is
 the simplest way to help others discover the project.

package/package.json

@@ -2,7 +2,7 @@
   "name": "picovolt",
   "type": "module",
   "description": "PicoVolt (PVDB): a polymorphic embedded database engine in Rust.",
-  "version": "0.12.0",
+  "version": "1.1.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/picovolt.d.ts

@@ -25,6 +25,13 @@ export class Db {
      * Create a new, empty in-memory database.
      */
     constructor();
+    /**
+     * Open a baked `.pvdb` served over HTTP **without downloading it whole**:
+     * `read(offset, len)` must synchronously return a `Uint8Array` of that byte
+     * range (e.g. a synchronous range request). Pages are then fetched on demand
+     * as queries touch them. `totalSize` is the image's byte length.
+     */
+    static openRemote(read: Function, total_size: number): Db;
     /**
      * Run one SQL statement, optionally binding `?` placeholders to `params` (a
      * JS array, e.g. `db.query("SELECT * FROM t WHERE id = ?", [1])`). Returns a
@@ -33,4 +40,9 @@ export class Db {
      * `{"done":true}` otherwise. Throws the error message (a string) on failure.
      */
     query(sql: string, params: any): string;
+    /**
+     * A JSON array of the table names in this database (for introspecting an
+     * uploaded `.pvdb` whose schema is unknown).
+     */
+    tables(): string;
 }

package/picovolt_bg.js

@@ -64,6 +64,22 @@ export class Db {
         DbFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Open a baked `.pvdb` served over HTTP **without downloading it whole**:
+     * `read(offset, len)` must synchronously return a `Uint8Array` of that byte
+     * range (e.g. a synchronous range request). Pages are then fetched on demand
+     * as queries touch them. `totalSize` is the image's byte length.
+     * @param {Function} read
+     * @param {number} total_size
+     * @returns {Db}
+     */
+    static openRemote(read, total_size) {
+        const ret = wasm.db_openRemote(read, total_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Db.__wrap(ret[0]);
+    }
     /**
      * Run one SQL statement, optionally binding `?` placeholders to `params` (a
      * JS array, e.g. `db.query("SELECT * FROM t WHERE id = ?", [1])`). Returns a
@@ -94,6 +110,29 @@ export class Db {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * A JSON array of the table names in this database (for introspecting an
+     * uploaded `.pvdb` whose schema is unknown).
+     * @returns {string}
+     */
+    tables() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.db_tables(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
 }
 if (Symbol.dispose) Db.prototype[Symbol.dispose] = Db.prototype.free;
 export function __wbg___wbindgen_boolean_get_fa956cfa2d1bd751(arg0) {
@@ -101,6 +140,13 @@ export function __wbg___wbindgen_boolean_get_fa956cfa2d1bd751(arg0) {
     const ret = typeof(v) === 'boolean' ? v : undefined;
     return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
 }
+export function __wbg___wbindgen_debug_string_c25d447a39f5578f(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
 export function __wbg___wbindgen_is_null_ea9085d691f535d3(arg0) {
     const ret = arg0 === null;
     return ret;
@@ -126,6 +172,10 @@ export function __wbg___wbindgen_string_get_b0ca35b86a603356(arg0, arg1) {
 export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 }
+export function __wbg_call_e3b662382210db98() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.call(arg1, arg2, arg3);
+    return ret;
+}, arguments); }
 export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
     let deferred0_0;
     let deferred0_1;
@@ -145,6 +195,20 @@ export function __wbg_get_unchecked_6e0ad6d2a41b06f6(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
+export function __wbg_instanceof_Uint8Array_309b927aaf7a3fc7(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_length_1f0964f4a5e2c6d8(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
 export function __wbg_length_370319915dc99107(arg0) {
     const ret = arg0.length;
     return ret;
@@ -153,6 +217,9 @@ export function __wbg_new_227d7c05414eb861() {
     const ret = new Error();
     return ret;
 }
+export function __wbg_prototypesetcall_4770620bbe4688a0(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
 export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     const ret = arg1.stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -160,7 +227,12 @@ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
-export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+export function __wbindgen_cast_0000000000000001(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
@@ -178,6 +250,77 @@ const DbFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_db_free(ptr, 1));
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -203,6 +346,15 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }