Remove str and prepare_v2 functions.

src/sqlite-api.js

@@ -521,21 +521,21 @@ export function Factory(Module) {
     };
   })();
 
-  sqlite3.prepare_v2 = (function() {
-    const fname = 'sqlite3_prepare_v2';
-    const f = Module.cwrap(fname, ...decl('nnnnn:n'), { async });
-    return async function(db, sql) {
-      const result = await f(db, sql, -1, tmpPtr[0], tmpPtr[1]);
-      check(fname, result, db);
-
-      const stmt = Module.getValue(tmpPtr[0], '*');
-      if (stmt) {
-        mapStmtToDB.set(stmt, db);
-        return { stmt, sql: Module.getValue(tmpPtr[1], '*') };
-      }
-      return null;
-    };
-  })();
+  // sqlite3.prepare_v2 = (function() {
+  //   const fname = 'sqlite3_prepare_v2';
+  //   const f = Module.cwrap(fname, ...decl('nnnnn:n'), { async });
+  //   return async function(db, sql) {
+  //     const result = await f(db, sql, -1, tmpPtr[0], tmpPtr[1]);
+  //     check(fname, result, db);
+
+  //     const stmt = Module.getValue(tmpPtr[0], '*');
+  //     if (stmt) {
+  //       mapStmtToDB.set(stmt, db);
+  //       return { stmt, sql: Module.getValue(tmpPtr[1], '*') };
+  //     }
+  //     return null;
+  //   };
+  // })();
 
   sqlite3.progress_handler = function(db, nProgressOps, handler, userData) {
     verifyDatabase(db);
@@ -769,60 +769,6 @@ export function Factory(Module) {
     };
   })();
 
-  // Duplicate some of the SQLite dynamic string API but without
-  // calling SQLite (except for memory allocation). We need some way
-  // to transfer Javascript strings and might as well use an API
-  // that mimics the SQLite API.
-  let stringId = 0;
-  const strings = new Map();
-
-  sqlite3.str_new = function(db, s = '') {
-    const sBytes = Module.lengthBytesUTF8(s);
-    const str = stringId++ & 0xffffffff;
-    const data = {
-      offset: Module._sqlite3_malloc(sBytes + 1),
-      bytes: sBytes
-    };
-    strings.set(str, data);
-    Module.stringToUTF8(s, data.offset, data.bytes + 1);
-    return str;
-  };
-
-  sqlite3.str_appendall = function(str, s) {
-    if (!strings.has(str)) {
-      throw new SQLiteError('not a string', SQLite.SQLITE_MISUSE);
-    }
-    const data = strings.get(str);
-
-    const sBytes = Module.lengthBytesUTF8(s);
-    const newBytes = data.bytes + sBytes;
-    const newOffset = Module._sqlite3_malloc(newBytes + 1);
-    const newArray = Module.HEAPU8.subarray(newOffset, newOffset + newBytes + 1);
-    newArray.set(Module.HEAPU8.subarray(data.offset, data.offset + data.bytes));
-    Module.stringToUTF8(s, newOffset + data.bytes, sBytes + 1);
-
-    Module._sqlite3_free(data.offset);
-    data.offset = newOffset;
-    data.bytes = newBytes;
-    strings.set(str, data);
-  };
-
-  sqlite3.str_finish = function(str) {
-    if (!strings.has(str)) {
-      throw new SQLiteError('not a string', SQLite.SQLITE_MISUSE);
-    }
-    const data = strings.get(str);
-    strings.delete(str);
-    Module._sqlite3_free(data.offset);
-  };
-
-  sqlite3.str_value = function(str) {
-    if (!strings.has(str)) {
-      throw new SQLiteError('not a string', SQLite.SQLITE_MISUSE);
-    }
-    return strings.get(str).offset;
-  };
-
   sqlite3.value = function(pValue) {
     const type = sqlite3.value_type(pValue);
     switch (type) {

src/types/index.d.ts

@@ -723,51 +723,6 @@ declare interface SQLiteAPI {
     zVfs?: string    
   ): Promise<number>;
 
-  /**
-   * Compile an SQL statement
-   * 
-   * SQL is provided as a pointer in WASM memory, so the utility functions
-   * {@link str_new} and {@link str_value} should be used. The returned
-   * Promise-wrapped object provides both the prepared statement and a
-   * pointer to the still uncompiled SQL that can be used with the next
-   * call to this function. A Promise containing `null` is returned
-   * when no statement remains.
-   * 
-   * Each prepared statement should be destroyed with {@link finalize}
-   * after its usage is complete.
-   * 
-   * Code using {@link prepare_v2} generally looks like this:
-   * ```javascript
-   * const str = sqlite3.str_new(db, sql);
-   * try {
-   *   // Traverse and prepare the SQL, statement by statement.
-   *   let prepared = { stmt: null, sql: sqlite3.str_value(str) };
-   *   while ((prepared = await sqlite3.prepare_v2(db, prepared.sql))) {
-   *     try {
-   *       // Step through the rows produced by the statement.
-   *       while (await sqlite3.step(prepared.stmt) === SQLite.SQLITE_ROW) {
-   *         // Do something with the row data...
-   *       }
-   *     } finally {
-   *       sqlite3.finalize(prepared.stmt);
-   *     }
-   *   }
-   * } finally {
-   *   sqlite3.str_finish(str);
-   * }
-   * ```
-   * 
-   * The {@link statements} convenience function can be used to
-   * avoid the boilerplate of calling {@link prepare_v2} directly.
-   * @see https://www.sqlite.org/c3ref/prepare.html
-   * @param db database pointer
-   * @param sql SQL pointer
-   * @returns Promise-wrapped object containing the prepared statement
-   * pointer and next SQL pointer, or a Promise containing `null` when
-   * no statement remains
-   */
-  prepare_v2(db: number, sql: number): Promise<{ stmt: number, sql: number}|null>;
-
   /**
    * Specify callback to be invoked between long-running queries
    * 
@@ -923,58 +878,6 @@ declare interface SQLiteAPI {
    */
   step(stmt: number): Promise<number>;
 
-  /**
-   * Create a new `sqlite3_str` dynamic string instance
-   * 
-   * The purpose for `sqlite3_str` is to transfer a SQL string in
-   * Javascript to WebAssembly memory for use with {@link prepare_v2}.
-   * 
-   * An optional initialization argument has been added for convenience
-   * which is functionally equivalent to (but slightly more efficient):
-   *  ```javascript
-   *  const str = sqlite3.str_new(db);
-   *  sqlite3.str_appendall(str, s);
-   *  ```
-   * 
-   * A `sqlite3_str` instance should always be destroyed with
-   * {@link str_finish} after use to avoid a resource leak.
-   * 
-   * @see https://www.sqlite.org/c3ref/str_append.html
-   * @param db database pointer
-   * @param s optional initialization string
-   * @returns `sqlite3_str` pointer
-   */
-  str_new(db: number, s?:string): number;
-
-  /**
-   * Add content to a `sqlite3_str` dynamic string
-   * 
-   * Not recommended for building strings incrementally; prefer using
-   * Javascript and {@link str_new} with initialization.
-   * @see https://www.sqlite.org/c3ref/str_append.html
-   * @param str `sqlite3_str` pointer
-   * @param s string to append
-   */
-  str_appendall(str: number, s: string): void;
-
-  /**
-   * Get pointer to `sqlite3_str` dynamic string data
-   * 
-   * The returned pointer points to the UTF-8 encoded string in
-   * WebAssembly memory. Use as input with {@link prepare_v2}.
-   * @see https://www.sqlite.org/c3ref/str_errcode.html
-   * @param str `sqlite3_str` pointer
-   * @returns pointer to string data
-   */
-  str_value(str: number): number;
-
-  /**
-   * Finalize a `sqlite3_str` dynamic string created with {@link str_new}
-   * @see https://www.sqlite.org/c3ref/str_append.html
-   * @param str `sqlite3_str` pointer
-   */
-  str_finish(str: number): void;
-
   /**
    * Extract a value from `sqlite3_value`
    * 

test/api.test.js

@@ -1,7 +1,6 @@
 import { TestContext } from "./TestContext.js";
 import { api_exec } from "./api_exec.js";
 import { api_misc } from "./api_misc.js";
-import { api_prepare } from "./api_prepare.js";
 import { api_statements } from "./api_statements.js";
 
 function apiSpecs(build, config) {
@@ -10,7 +9,6 @@ function apiSpecs(build, config) {
   describe(`SQLite ${build} ${config}`, function() {
     api_exec(context);
     api_misc(context);
-    api_prepare(context);
     api_statements(context);
   });
 }