| /* |
| 2022-07-22 |
| |
| The author disclaims copyright to this source code. In place of a |
| legal notice, here is a blessing: |
| |
| * May you do good and not evil. |
| * May you find forgiveness for yourself and forgive others. |
| * May you share freely, never taking more than you give. |
| |
| *********************************************************************** |
| |
| This file glues together disparate pieces of JS which are loaded in |
| previous steps of the sqlite3-api.js bootstrapping process: |
| sqlite3-api-prologue.js, whwasmutil.js, and jaccwabyt.js. It |
| initializes the main API pieces so that the downstream components |
| (e.g. sqlite3-api-oo1.js) have all of the infrastructure that they |
| need. |
| */ |
| globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ |
| 'use strict'; |
| const toss = (...args)=>{throw new Error(args.join(' '))}; |
| const toss3 = sqlite3.SQLite3Error.toss; |
| const capi = sqlite3.capi, wasm = sqlite3.wasm, util = sqlite3.util; |
| globalThis.WhWasmUtilInstaller(wasm); |
| delete globalThis.WhWasmUtilInstaller; |
| |
| if(0){ |
| /** |
| Please keep this block around as a maintenance reminder |
| that we cannot rely on this type of check. |
| |
| This block fails on Safari, per a report at |
| https://sqlite.org/forum/forumpost/e5b20e1feb. |
| |
| It turns out that what Safari serves from the indirect function |
| table (e.g. wasm.functionEntry(X)) is anonymous functions which |
| wrap the WASM functions, rather than returning the WASM |
| functions themselves. That means comparison of such functions |
| is useless for determining whether or not we have a specific |
| function from wasm.exports. i.e. if function X is indirection |
| function table entry N then wasm.exports.X is not equal to |
| wasm.functionEntry(N) in Safari, despite being so in the other |
| browsers. |
| */ |
| /** |
| Find a mapping for SQLITE_WASM_DEALLOC, which the API |
| guarantees is a WASM pointer to the same underlying function as |
| wasm.dealloc() (noting that wasm.dealloc() is permitted to be a |
| JS wrapper around the WASM function). There is unfortunately no |
| O(1) algorithm for finding this pointer: we have to walk the |
| WASM indirect function table to find it. However, experience |
| indicates that that particular function is always very close to |
| the front of the table (it's been entry #3 in all relevant |
| tests). |
| */ |
| const dealloc = wasm.exports[sqlite3.config.deallocExportName]; |
| const nFunc = wasm.functionTable().length; |
| let i; |
| for(i = 0; i < nFunc; ++i){ |
| const e = wasm.functionEntry(i); |
| if(dealloc === e){ |
| capi.SQLITE_WASM_DEALLOC = i; |
| break; |
| } |
| } |
| if(dealloc !== wasm.functionEntry(capi.SQLITE_WASM_DEALLOC)){ |
| toss("Internal error: cannot find function pointer for SQLITE_WASM_DEALLOC."); |
| } |
| } |
| |
| /** |
| Signatures for the WASM-exported C-side functions. Each entry |
| is an array with 2+ elements: |
| |
| [ "c-side name", |
| "result type" (wasm.xWrap() syntax), |
| [arg types in xWrap() syntax] |
| // ^^^ this needn't strictly be an array: it can be subsequent |
| // elements instead: [x,y,z] is equivalent to x,y,z |
| ] |
| |
| Note that support for the API-specific data types in the |
| result/argument type strings gets plugged in at a later phase in |
| the API initialization process. |
| */ |
| wasm.bindingSignatures = [ |
| // Please keep these sorted by function name! |
| ["sqlite3_aggregate_context","void*", "sqlite3_context*", "int"], |
| /* sqlite3_auto_extension() has a hand-written binding. */ |
| /* sqlite3_bind_blob() and sqlite3_bind_text() have hand-written |
| bindings to permit more flexible inputs. */ |
| ["sqlite3_bind_double","int", "sqlite3_stmt*", "int", "f64"], |
| ["sqlite3_bind_int","int", "sqlite3_stmt*", "int", "int"], |
| ["sqlite3_bind_null",undefined, "sqlite3_stmt*", "int"], |
| ["sqlite3_bind_parameter_count", "int", "sqlite3_stmt*"], |
| ["sqlite3_bind_parameter_index","int", "sqlite3_stmt*", "string"], |
| ["sqlite3_bind_parameter_name", "string", "sqlite3_stmt*", "int"], |
| ["sqlite3_bind_pointer", "int", |
| "sqlite3_stmt*", "int", "*", "string:static", "*"], |
| ["sqlite3_busy_handler","int", [ |
| "sqlite3*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| signature: 'i(pi)', |
| contextKey: (argv,argIndex)=>argv[0/* sqlite3* */] |
| }), |
| "*" |
| ]], |
| ["sqlite3_busy_timeout","int", "sqlite3*", "int"], |
| /* sqlite3_cancel_auto_extension() has a hand-written binding. */ |
| /* sqlite3_close_v2() is implemented by hand to perform some |
| extra work. */ |
| ["sqlite3_changes", "int", "sqlite3*"], |
| ["sqlite3_clear_bindings","int", "sqlite3_stmt*"], |
| ["sqlite3_collation_needed", "int", "sqlite3*", "*", "*"/*=>v(ppis)*/], |
| ["sqlite3_column_blob","*", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_bytes","int", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_count", "int", "sqlite3_stmt*"], |
| ["sqlite3_column_decltype", "string", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_double","f64", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_int","int", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_name","string", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_text","string", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_type","int", "sqlite3_stmt*", "int"], |
| ["sqlite3_column_value","sqlite3_value*", "sqlite3_stmt*", "int"], |
| ["sqlite3_commit_hook", "void*", [ |
| "sqlite3*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'sqlite3_commit_hook', |
| signature: 'i(p)', |
| contextKey: (argv)=>argv[0/* sqlite3* */] |
| }), |
| '*' |
| ]], |
| ["sqlite3_compileoption_get", "string", "int"], |
| ["sqlite3_compileoption_used", "int", "string"], |
| ["sqlite3_complete", "int", "string:flexible"], |
| ["sqlite3_context_db_handle", "sqlite3*", "sqlite3_context*"], |
| /* sqlite3_create_collation() and sqlite3_create_collation_v2() |
| use hand-written bindings to simplify passing of the callback |
| function. */ |
| /* sqlite3_create_function(), sqlite3_create_function_v2(), and |
| sqlite3_create_window_function() use hand-written bindings to |
| simplify handling of their function-type arguments. */ |
| ["sqlite3_data_count", "int", "sqlite3_stmt*"], |
| ["sqlite3_db_filename", "string", "sqlite3*", "string"], |
| ["sqlite3_db_handle", "sqlite3*", "sqlite3_stmt*"], |
| ["sqlite3_db_name", "string", "sqlite3*", "int"], |
| ["sqlite3_db_readonly", "int", "sqlite3*", "string"], |
| ["sqlite3_db_status", "int", "sqlite3*", "int", "*", "*", "int"], |
| ["sqlite3_errcode", "int", "sqlite3*"], |
| ["sqlite3_errmsg", "string", "sqlite3*"], |
| ["sqlite3_error_offset", "int", "sqlite3*"], |
| ["sqlite3_errstr", "string", "int"], |
| ["sqlite3_exec", "int", [ |
| "sqlite3*", "string:flexible", |
| new wasm.xWrap.FuncPtrAdapter({ |
| signature: 'i(pipp)', |
| bindScope: 'transient', |
| callProxy: (callback)=>{ |
| let aNames; |
| return (pVoid, nCols, pColVals, pColNames)=>{ |
| try { |
| const aVals = wasm.cArgvToJs(nCols, pColVals); |
| if(!aNames) aNames = wasm.cArgvToJs(nCols, pColNames); |
| return callback(aVals, aNames) | 0; |
| }catch(e){ |
| /* If we set the db error state here, the higher-level |
| exec() call replaces it with its own, so we have no way |
| of reporting the exception message except the console. We |
| must not propagate exceptions through the C API. Though |
| we make an effort to report OOM here, sqlite3_exec() |
| translates that into SQLITE_ABORT as well. */ |
| return e.resultCode || capi.SQLITE_ERROR; |
| } |
| } |
| } |
| }), |
| "*", "**" |
| ]], |
| ["sqlite3_expanded_sql", "string", "sqlite3_stmt*"], |
| ["sqlite3_extended_errcode", "int", "sqlite3*"], |
| ["sqlite3_extended_result_codes", "int", "sqlite3*", "int"], |
| ["sqlite3_file_control", "int", "sqlite3*", "string", "int", "*"], |
| ["sqlite3_finalize", "int", "sqlite3_stmt*"], |
| ["sqlite3_free", undefined,"*"], |
| ["sqlite3_get_autocommit", "int", "sqlite3*"], |
| ["sqlite3_get_auxdata", "*", "sqlite3_context*", "int"], |
| ["sqlite3_initialize", undefined], |
| ["sqlite3_interrupt", undefined, "sqlite3*"], |
| ["sqlite3_is_interrupted", "int", "sqlite3*"], |
| ["sqlite3_keyword_count", "int"], |
| ["sqlite3_keyword_name", "int", ["int", "**", "*"]], |
| ["sqlite3_keyword_check", "int", ["string", "int"]], |
| ["sqlite3_libversion", "string"], |
| ["sqlite3_libversion_number", "int"], |
| ["sqlite3_limit", "int", ["sqlite3*", "int", "int"]], |
| ["sqlite3_malloc", "*","int"], |
| ["sqlite3_open", "int", "string", "*"], |
| ["sqlite3_open_v2", "int", "string", "*", "int", "string"], |
| /* sqlite3_prepare_v2() and sqlite3_prepare_v3() are handled |
| separately due to us requiring two different sets of semantics |
| for those, depending on how their SQL argument is provided. */ |
| /* sqlite3_randomness() uses a hand-written wrapper to extend |
| the range of supported argument types. */ |
| ["sqlite3_realloc", "*","*","int"], |
| ["sqlite3_reset", "int", "sqlite3_stmt*"], |
| /* sqlite3_reset_auto_extension() has a hand-written binding. */ |
| ["sqlite3_result_blob", undefined, "sqlite3_context*", "*", "int", "*"], |
| ["sqlite3_result_double", undefined, "sqlite3_context*", "f64"], |
| ["sqlite3_result_error", undefined, "sqlite3_context*", "string", "int"], |
| ["sqlite3_result_error_code", undefined, "sqlite3_context*", "int"], |
| ["sqlite3_result_error_nomem", undefined, "sqlite3_context*"], |
| ["sqlite3_result_error_toobig", undefined, "sqlite3_context*"], |
| ["sqlite3_result_int", undefined, "sqlite3_context*", "int"], |
| ["sqlite3_result_null", undefined, "sqlite3_context*"], |
| ["sqlite3_result_pointer", undefined, |
| "sqlite3_context*", "*", "string:static", "*"], |
| ["sqlite3_result_subtype", undefined, "sqlite3_value*", "int"], |
| ["sqlite3_result_text", undefined, "sqlite3_context*", "string", "int", "*"], |
| ["sqlite3_result_zeroblob", undefined, "sqlite3_context*", "int"], |
| ["sqlite3_rollback_hook", "void*", [ |
| "sqlite3*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'sqlite3_rollback_hook', |
| signature: 'v(p)', |
| contextKey: (argv)=>argv[0/* sqlite3* */] |
| }), |
| '*' |
| ]], |
| ["sqlite3_set_auxdata", undefined, [ |
| "sqlite3_context*", "int", "*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xDestroyAuxData', |
| signature: 'v(*)', |
| contextKey: (argv, argIndex)=>argv[0/* sqlite3_context* */] |
| }) |
| ]], |
| ["sqlite3_shutdown", undefined], |
| ["sqlite3_sourceid", "string"], |
| ["sqlite3_sql", "string", "sqlite3_stmt*"], |
| ["sqlite3_status", "int", "int", "*", "*", "int"], |
| ["sqlite3_step", "int", "sqlite3_stmt*"], |
| ["sqlite3_stmt_busy", "int", "sqlite3_stmt*"], |
| ["sqlite3_stmt_readonly", "int", "sqlite3_stmt*"], |
| ["sqlite3_stmt_status", "int", "sqlite3_stmt*", "int", "int"], |
| ["sqlite3_strglob", "int", "string","string"], |
| ["sqlite3_stricmp", "int", "string", "string"], |
| ["sqlite3_strlike", "int", "string", "string","int"], |
| ["sqlite3_strnicmp", "int", "string", "string", "int"], |
| ["sqlite3_table_column_metadata", "int", |
| "sqlite3*", "string", "string", "string", |
| "**", "**", "*", "*", "*"], |
| ["sqlite3_total_changes", "int", "sqlite3*"], |
| ["sqlite3_trace_v2", "int", [ |
| "sqlite3*", "int", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'sqlite3_trace_v2::callback', |
| signature: 'i(ippp)', |
| contextKey: (argv,argIndex)=>argv[0/* sqlite3* */] |
| }), |
| "*" |
| ]], |
| ["sqlite3_txn_state", "int", ["sqlite3*","string"]], |
| /* Note that sqlite3_uri_...() have very specific requirements for |
| their first C-string arguments, so we cannot perform any value |
| conversion on those. */ |
| ["sqlite3_uri_boolean", "int", "sqlite3_filename", "string", "int"], |
| ["sqlite3_uri_key", "string", "sqlite3_filename", "int"], |
| ["sqlite3_uri_parameter", "string", "sqlite3_filename", "string"], |
| ["sqlite3_user_data","void*", "sqlite3_context*"], |
| ["sqlite3_value_blob", "*", "sqlite3_value*"], |
| ["sqlite3_value_bytes","int", "sqlite3_value*"], |
| ["sqlite3_value_double","f64", "sqlite3_value*"], |
| ["sqlite3_value_dup", "sqlite3_value*", "sqlite3_value*"], |
| ["sqlite3_value_free", undefined, "sqlite3_value*"], |
| ["sqlite3_value_frombind", "int", "sqlite3_value*"], |
| ["sqlite3_value_int","int", "sqlite3_value*"], |
| ["sqlite3_value_nochange", "int", "sqlite3_value*"], |
| ["sqlite3_value_numeric_type", "int", "sqlite3_value*"], |
| ["sqlite3_value_pointer", "*", "sqlite3_value*", "string:static"], |
| ["sqlite3_value_subtype", "int", "sqlite3_value*"], |
| ["sqlite3_value_text", "string", "sqlite3_value*"], |
| ["sqlite3_value_type", "int", "sqlite3_value*"], |
| ["sqlite3_vfs_find", "*", "string"], |
| ["sqlite3_vfs_register", "int", "sqlite3_vfs*", "int"], |
| ["sqlite3_vfs_unregister", "int", "sqlite3_vfs*"] |
| ]/*wasm.bindingSignatures*/; |
| |
| if( !!wasm.exports.sqlite3_progress_handler ){ |
| wasm.bindingSignatures.push( |
| ["sqlite3_progress_handler", undefined, [ |
| "sqlite3*", "int", new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xProgressHandler', |
| signature: 'i(p)', |
| bindScope: 'context', |
| contextKey: (argv,argIndex)=>argv[0/* sqlite3* */] |
| }), "*" |
| ]] |
| ); |
| } |
| |
| if( !!wasm.exports.sqlite3_stmt_explain ){ |
| wasm.bindingSignatures.push( |
| ["sqlite3_stmt_explain", "int", "sqlite3_stmt*", "int"], |
| ["sqlite3_stmt_isexplain", "int", "sqlite3_stmt*"] |
| ); |
| } |
| |
| if( !!wasm.exports.sqlite3_set_authorizer ){ |
| wasm.bindingSignatures.push( |
| ["sqlite3_set_authorizer", "int", [ |
| "sqlite3*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: "sqlite3_set_authorizer::xAuth", |
| signature: "i(pi"+"ssss)", |
| contextKey: (argv, argIndex)=>argv[0/*(sqlite3*)*/], |
| callProxy: (callback)=>{ |
| return (pV, iCode, s0, s1, s2, s3)=>{ |
| try{ |
| s0 = s0 && wasm.cstrToJs(s0); s1 = s1 && wasm.cstrToJs(s1); |
| s2 = s2 && wasm.cstrToJs(s2); s3 = s3 && wasm.cstrToJs(s3); |
| return callback(pV, iCode, s0, s1, s2, s3) || 0; |
| }catch(e){ |
| return e.resultCode || capi.SQLITE_ERROR; |
| } |
| } |
| } |
| }), |
| "*"/*pUserData*/ |
| ]] |
| ); |
| }/* sqlite3_set_authorizer() */ |
| |
| if(false && wasm.compileOptionUsed('SQLITE_ENABLE_NORMALIZE')){ |
| /* ^^^ "the problem" is that this is an optional feature and the |
| build-time function-export list does not currently take |
| optional features into account. */ |
| wasm.bindingSignatures.push(["sqlite3_normalized_sql", "string", "sqlite3_stmt*"]); |
| } |
| |
| //#if enable-see |
| if(wasm.exports.sqlite3_key_v2 instanceof Function){ |
| /** |
| This code is capable of using an SEE build but note that an SEE |
| WASM build is generally incompatible with SEE's license |
| conditions. It is permitted for use internally in organizations |
| which have licensed SEE, but not for public sites because |
| exposing an SEE build of sqlite3.wasm effectively provides all |
| clients with a working copy of the commercial SEE code. |
| */ |
| wasm.bindingSignatures.push( |
| ["sqlite3_key", "int", "sqlite3*", "string", "int"], |
| ["sqlite3_key_v2","int","sqlite3*","string","*","int"], |
| ["sqlite3_rekey", "int", "sqlite3*", "string", "int"], |
| ["sqlite3_rekey_v2", "int", "sqlite3*", "string", "*", "int"], |
| ["sqlite3_activate_see", undefined, "string"] |
| ); |
| } |
| //#endif enable-see |
| |
| /** |
| Functions which require BigInt (int64) support are separated from |
| the others because we need to conditionally bind them or apply |
| dummy impls, depending on the capabilities of the environment. |
| (That said: we never actually build without BigInt support, |
| and such builds are untested.) |
| |
| Note that not all of these functions directly require int64 |
| but are only for use with APIs which require int64. For example, |
| the vtab-related functions. |
| */ |
| wasm.bindingSignatures.int64 = [ |
| ["sqlite3_bind_int64","int", ["sqlite3_stmt*", "int", "i64"]], |
| ["sqlite3_changes64","i64", ["sqlite3*"]], |
| ["sqlite3_column_int64","i64", ["sqlite3_stmt*", "int"]], |
| ["sqlite3_deserialize", "int", "sqlite3*", "string", "*", "i64", "i64", "int"] |
| /* Careful! Short version: de/serialize() are problematic because they |
| might use a different allocator than the user for managing the |
| deserialized block. de/serialize() are ONLY safe to use with |
| sqlite3_malloc(), sqlite3_free(), and its 64-bit variants. Because |
| of this, the canonical builds of sqlite3.wasm/js guarantee that |
| sqlite3.wasm.alloc() and friends use those allocators. Custom builds |
| may not guarantee that, however. */, |
| ["sqlite3_last_insert_rowid", "i64", ["sqlite3*"]], |
| ["sqlite3_malloc64", "*","i64"], |
| ["sqlite3_msize", "i64", "*"], |
| ["sqlite3_overload_function", "int", ["sqlite3*","string","int"]], |
| ["sqlite3_realloc64", "*","*", "i64"], |
| ["sqlite3_result_int64", undefined, "*", "i64"], |
| ["sqlite3_result_zeroblob64", "int", "*", "i64"], |
| ["sqlite3_serialize","*", "sqlite3*", "string", "*", "int"], |
| ["sqlite3_set_last_insert_rowid", undefined, ["sqlite3*", "i64"]], |
| ["sqlite3_status64", "int", "int", "*", "*", "int"], |
| ["sqlite3_total_changes64", "i64", ["sqlite3*"]], |
| ["sqlite3_update_hook", "*", [ |
| "sqlite3*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'sqlite3_update_hook', |
| signature: "v(iippj)", |
| contextKey: (argv)=>argv[0/* sqlite3* */], |
| callProxy: (callback)=>{ |
| return (p,op,z0,z1,rowid)=>{ |
| callback(p, op, wasm.cstrToJs(z0), wasm.cstrToJs(z1), rowid); |
| }; |
| } |
| }), |
| "*" |
| ]], |
| ["sqlite3_uri_int64", "i64", ["sqlite3_filename", "string", "i64"]], |
| ["sqlite3_value_int64","i64", "sqlite3_value*"] |
| ]; |
| |
| if( wasm.bigIntEnabled && !!wasm.exports.sqlite3_declare_vtab ){ |
| wasm.bindingSignatures.int64.push( |
| ["sqlite3_create_module", "int", |
| ["sqlite3*","string","sqlite3_module*","*"]], |
| ["sqlite3_create_module_v2", "int", |
| ["sqlite3*","string","sqlite3_module*","*","*"]], |
| ["sqlite3_declare_vtab", "int", ["sqlite3*", "string:flexible"]], |
| ["sqlite3_drop_modules", "int", ["sqlite3*", "**"]], |
| ["sqlite3_vtab_collation","string","sqlite3_index_info*","int"], |
| ["sqlite3_vtab_distinct","int", "sqlite3_index_info*"], |
| ["sqlite3_vtab_in","int", "sqlite3_index_info*", "int", "int"], |
| ["sqlite3_vtab_in_first", "int", "sqlite3_value*", "**"], |
| ["sqlite3_vtab_in_next", "int", "sqlite3_value*", "**"], |
| /*["sqlite3_vtab_config" is variadic and requires a hand-written |
| proxy.] */ |
| ["sqlite3_vtab_nochange","int", "sqlite3_context*"], |
| ["sqlite3_vtab_on_conflict","int", "sqlite3*"], |
| ["sqlite3_vtab_rhs_value","int", "sqlite3_index_info*", "int", "**"] |
| ); |
| }/* virtual table APIs */ |
| |
| if(wasm.bigIntEnabled && !!wasm.exports.sqlite3_preupdate_hook){ |
| wasm.bindingSignatures.int64.push( |
| ["sqlite3_preupdate_blobwrite", "int", "sqlite3*"], |
| ["sqlite3_preupdate_count", "int", "sqlite3*"], |
| ["sqlite3_preupdate_depth", "int", "sqlite3*"], |
| ["sqlite3_preupdate_hook", "*", [ |
| "sqlite3*", |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'sqlite3_preupdate_hook', |
| signature: "v(ppippjj)", |
| contextKey: (argv)=>argv[0/* sqlite3* */], |
| callProxy: (callback)=>{ |
| return (p,db,op,zDb,zTbl,iKey1,iKey2)=>{ |
| callback(p, db, op, wasm.cstrToJs(zDb), wasm.cstrToJs(zTbl), |
| iKey1, iKey2); |
| }; |
| } |
| }), |
| "*" |
| ]], |
| ["sqlite3_preupdate_new", "int", ["sqlite3*", "int", "**"]], |
| ["sqlite3_preupdate_old", "int", ["sqlite3*", "int", "**"]] |
| ); |
| } /* preupdate API */ |
| |
| // Add session/changeset APIs... |
| if(wasm.bigIntEnabled |
| && !!wasm.exports.sqlite3changegroup_add |
| && !!wasm.exports.sqlite3session_create |
| && !!wasm.exports.sqlite3_preupdate_hook /* required by the session API */){ |
| /** |
| FuncPtrAdapter options for session-related callbacks with the |
| native signature "i(ps)". This proxy converts the 2nd argument |
| from a C string to a JS string before passing the arguments on |
| to the client-provided JS callback. |
| */ |
| const __ipsProxy = { |
| signature: 'i(ps)', |
| callProxy:(callback)=>{ |
| return (p,s)=>{ |
| try{return callback(p, wasm.cstrToJs(s)) | 0} |
| catch(e){return e.resultCode || capi.SQLITE_ERROR} |
| } |
| } |
| }; |
| |
| wasm.bindingSignatures.int64.push(...[ |
| ['sqlite3changegroup_add', 'int', ['sqlite3_changegroup*', 'int', 'void*']], |
| ['sqlite3changegroup_add_strm', 'int', [ |
| 'sqlite3_changegroup*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changegroup_delete', undefined, ['sqlite3_changegroup*']], |
| ['sqlite3changegroup_new', 'int', ['**']], |
| ['sqlite3changegroup_output', 'int', ['sqlite3_changegroup*', 'int*', '**']], |
| ['sqlite3changegroup_output_strm', 'int', [ |
| 'sqlite3_changegroup*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changeset_apply', 'int', [ |
| 'sqlite3*', 'int', 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xFilter', bindScope: 'transient', ...__ipsProxy |
| }), |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changeset_apply_strm', 'int', [ |
| 'sqlite3*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xFilter', bindScope: 'transient', ...__ipsProxy |
| }), |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changeset_apply_v2', 'int', [ |
| 'sqlite3*', 'int', 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xFilter', bindScope: 'transient', ...__ipsProxy |
| }), |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' |
| }), |
| 'void*', '**', 'int*', 'int' |
| |
| ]], |
| ['sqlite3changeset_apply_v2_strm', 'int', [ |
| 'sqlite3*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xFilter', bindScope: 'transient', ...__ipsProxy |
| }), |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xConflict', signature: 'i(pip)', bindScope: 'transient' |
| }), |
| 'void*', '**', 'int*', 'int' |
| ]], |
| ['sqlite3changeset_concat', 'int', ['int','void*', 'int', 'void*', 'int*', '**']], |
| ['sqlite3changeset_concat_strm', 'int', [ |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInputA', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInputB', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changeset_conflict', 'int', ['sqlite3_changeset_iter*', 'int', '**']], |
| ['sqlite3changeset_finalize', 'int', ['sqlite3_changeset_iter*']], |
| ['sqlite3changeset_fk_conflicts', 'int', ['sqlite3_changeset_iter*', 'int*']], |
| ['sqlite3changeset_invert', 'int', ['int', 'void*', 'int*', '**']], |
| ['sqlite3changeset_invert_strm', 'int', [ |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changeset_new', 'int', ['sqlite3_changeset_iter*', 'int', '**']], |
| ['sqlite3changeset_next', 'int', ['sqlite3_changeset_iter*']], |
| ['sqlite3changeset_old', 'int', ['sqlite3_changeset_iter*', 'int', '**']], |
| ['sqlite3changeset_op', 'int', [ |
| 'sqlite3_changeset_iter*', '**', 'int*', 'int*','int*' |
| ]], |
| ['sqlite3changeset_pk', 'int', ['sqlite3_changeset_iter*', '**', 'int*']], |
| ['sqlite3changeset_start', 'int', ['**', 'int', '*']], |
| ['sqlite3changeset_start_strm', 'int', [ |
| '**', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3changeset_start_v2', 'int', ['**', 'int', '*', 'int']], |
| ['sqlite3changeset_start_v2_strm', 'int', [ |
| '**', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xInput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*', 'int' |
| ]], |
| ['sqlite3session_attach', 'int', ['sqlite3_session*', 'string']], |
| ['sqlite3session_changeset', 'int', ['sqlite3_session*', 'int*', '**']], |
| ['sqlite3session_changeset_size', 'i64', ['sqlite3_session*']], |
| ['sqlite3session_changeset_strm', 'int', [ |
| 'sqlite3_session*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xOutput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3session_config', 'int', ['int', 'void*']], |
| ['sqlite3session_create', 'int', ['sqlite3*', 'string', '**']], |
| //sqlite3session_delete() is bound manually |
| ['sqlite3session_diff', 'int', ['sqlite3_session*', 'string', 'string', '**']], |
| ['sqlite3session_enable', 'int', ['sqlite3_session*', 'int']], |
| ['sqlite3session_indirect', 'int', ['sqlite3_session*', 'int']], |
| ['sqlite3session_isempty', 'int', ['sqlite3_session*']], |
| ['sqlite3session_memory_used', 'i64', ['sqlite3_session*']], |
| ['sqlite3session_object_config', 'int', ['sqlite3_session*', 'int', 'void*']], |
| ['sqlite3session_patchset', 'int', ['sqlite3_session*', '*', '**']], |
| ['sqlite3session_patchset_strm', 'int', [ |
| 'sqlite3_session*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xOutput', signature: 'i(ppp)', bindScope: 'transient' |
| }), |
| 'void*' |
| ]], |
| ['sqlite3session_table_filter', undefined, [ |
| 'sqlite3_session*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| name: 'xFilter', ...__ipsProxy, |
| contextKey: (argv,argIndex)=>argv[0/* (sqlite3_session*) */] |
| }), |
| '*' |
| ]] |
| ]); |
| }/*session/changeset APIs*/ |
| |
| /** |
| Functions which are intended solely for API-internal use by the |
| WASM components, not client code. These get installed into |
| sqlite3.util. Some of them get exposed to clients via variants |
| in sqlite3_js_...(). |
| |
| 2024-01-11: these were renamed, with two underscores in the |
| prefix, to ensure that clients do not accidentally depend on |
| them. They have always been documented as internal-use-only, so |
| no clients "should" be depending on the old names. |
| */ |
| wasm.bindingSignatures.wasmInternal = [ |
| ["sqlite3__wasm_db_reset", "int", "sqlite3*"], |
| ["sqlite3__wasm_db_vfs", "sqlite3_vfs*", "sqlite3*","string"], |
| [/* DO NOT USE. This is deprecated since 2023-08-11 because it can |
| trigger assert() in debug builds when used with file sizes |
| which are not sizes to a multiple of a valid db page size. */ |
| "sqlite3__wasm_vfs_create_file", "int", "sqlite3_vfs*","string","*", "int" |
| ], |
| ["sqlite3__wasm_posix_create_file", "int", "string","*", "int"], |
| ["sqlite3__wasm_vfs_unlink", "int", "sqlite3_vfs*","string"], |
| ["sqlite3__wasm_qfmt_token","string:dealloc", "string","int"] |
| ]; |
| |
| /** |
| Install JS<->C struct bindings for the non-opaque struct types we |
| need... */ |
| sqlite3.StructBinder = globalThis.Jaccwabyt({ |
| heap: 0 ? wasm.memory : wasm.heap8u, |
| alloc: wasm.alloc, |
| dealloc: wasm.dealloc, |
| bigIntEnabled: wasm.bigIntEnabled, |
| memberPrefix: /* Never change this: this prefix is baked into any |
| amount of code and client-facing docs. */ '$' |
| }); |
| delete globalThis.Jaccwabyt; |
| |
| {// wasm.xWrap() bindings... |
| |
| /* Convert Arrays and certain TypedArrays to strings for |
| 'string:flexible'-type arguments */ |
| const __xString = wasm.xWrap.argAdapter('string'); |
| wasm.xWrap.argAdapter( |
| 'string:flexible', (v)=>__xString(util.flexibleString(v)) |
| ); |
| |
| /** |
| The 'string:static' argument adapter treats its argument as |
| either... |
| |
| - WASM pointer: assumed to be a long-lived C-string which gets |
| returned as-is. |
| |
| - Anything else: gets coerced to a JS string for use as a map |
| key. If a matching entry is found (as described next), it is |
| returned, else wasm.allocCString() is used to create a a new |
| string, map its pointer to (''+v) for the remainder of the |
| application's life, and returns that pointer value for this |
| call and all future calls which are passed a |
| string-equivalent argument. |
| |
| Use case: sqlite3_bind_pointer() and sqlite3_result_pointer() |
| call for "a static string and preferably a string |
| literal." This converter is used to ensure that the string |
| value seen by those functions is long-lived and behaves as they |
| need it to. |
| */ |
| wasm.xWrap.argAdapter( |
| 'string:static', |
| function(v){ |
| if(wasm.isPtr(v)) return v; |
| v = ''+v; |
| let rc = this[v]; |
| return rc || (this[v] = wasm.allocCString(v)); |
| }.bind(Object.create(null)) |
| ); |
| |
| /** |
| Add some descriptive xWrap() aliases for '*' intended to (A) |
| initially improve readability/correctness of |
| wasm.bindingSignatures and (B) provide automatic conversion |
| from higher-level representations, e.g. capi.sqlite3_vfs to |
| `sqlite3_vfs*` via capi.sqlite3_vfs.pointer. |
| */ |
| const __xArgPtr = wasm.xWrap.argAdapter('*'); |
| const nilType = function(){ |
| /*a class which no value can ever be an instance of*/ |
| }; |
| wasm.xWrap.argAdapter('sqlite3_filename', __xArgPtr) |
| ('sqlite3_context*', __xArgPtr) |
| ('sqlite3_value*', __xArgPtr) |
| ('void*', __xArgPtr) |
| ('sqlite3_changegroup*', __xArgPtr) |
| ('sqlite3_changeset_iter*', __xArgPtr) |
| ('sqlite3_session*', __xArgPtr) |
| ('sqlite3_stmt*', (v)=> |
| __xArgPtr((v instanceof (sqlite3?.oo1?.Stmt || nilType)) |
| ? v.pointer : v)) |
| ('sqlite3*', (v)=> |
| __xArgPtr((v instanceof (sqlite3?.oo1?.DB || nilType)) |
| ? v.pointer : v)) |
| /** |
| `sqlite3_vfs*`: |
| |
| - v is-a string: use the result of sqlite3_vfs_find(v) but |
| throw if it returns 0. |
| - v is-a capi.sqlite3_vfs: use v.pointer. |
| - Else return the same as the `'*'` argument conversion. |
| */ |
| ('sqlite3_vfs*', (v)=>{ |
| if('string'===typeof v){ |
| /* A NULL sqlite3_vfs pointer will be treated as the default |
| VFS in many contexts. We specifically do not want that |
| behavior here. */ |
| return capi.sqlite3_vfs_find(v) |
| || sqlite3.SQLite3Error.toss( |
| capi.SQLITE_NOTFOUND, |
| "Unknown sqlite3_vfs name:", v |
| ); |
| } |
| return __xArgPtr((v instanceof (capi.sqlite3_vfs || nilType)) |
| ? v.pointer : v); |
| }); |
| if( wasm.exports.sqlite3_declare_vtab ){ |
| wasm.xWrap.argAdapter('sqlite3_index_info*', (v)=> |
| __xArgPtr((v instanceof (capi.sqlite3_index_info || nilType)) |
| ? v.pointer : v)) |
| ('sqlite3_module*', (v)=> |
| __xArgPtr((v instanceof (capi.sqlite3_module || nilType)) |
| ? v.pointer : v) |
| ); |
| } |
| |
| const __xRcPtr = wasm.xWrap.resultAdapter('*'); |
| wasm.xWrap.resultAdapter('sqlite3*', __xRcPtr) |
| ('sqlite3_context*', __xRcPtr) |
| ('sqlite3_stmt*', __xRcPtr) |
| ('sqlite3_value*', __xRcPtr) |
| ('sqlite3_vfs*', __xRcPtr) |
| ('void*', __xRcPtr); |
| |
| /** |
| Populate api object with sqlite3_...() by binding the "raw" wasm |
| exports into type-converting proxies using wasm.xWrap(). |
| */ |
| if(0 === wasm.exports.sqlite3_step.length){ |
| /* This environment wraps exports in nullary functions, which means |
| we must disable the arg-count validation we otherwise perform |
| on the wrappers. */ |
| wasm.xWrap.doArgcCheck = false; |
| sqlite3.config.warn( |
| "Disabling sqlite3.wasm.xWrap.doArgcCheck due to environmental quirks." |
| ); |
| } |
| for(const e of wasm.bindingSignatures){ |
| capi[e[0]] = wasm.xWrap.apply(null, e); |
| } |
| for(const e of wasm.bindingSignatures.wasmInternal){ |
| util[e[0]] = wasm.xWrap.apply(null, e); |
| } |
| |
| /* For C API functions which cannot work properly unless |
| wasm.bigIntEnabled is true, install a bogus impl which throws |
| if called when bigIntEnabled is false. The alternative would be |
| to elide these functions altogether, which seems likely to |
| cause more confusion. */ |
| const fI64Disabled = function(fname){ |
| return ()=>toss(fname+"() is unavailable due to lack", |
| "of BigInt support in this build."); |
| }; |
| for(const e of wasm.bindingSignatures.int64){ |
| capi[e[0]] = wasm.bigIntEnabled |
| ? wasm.xWrap.apply(null, e) |
| : fI64Disabled(e[0]); |
| } |
| |
| /* There's no need to expose bindingSignatures to clients, |
| implicitly making it part of the public interface. */ |
| delete wasm.bindingSignatures; |
| |
| if(wasm.exports.sqlite3__wasm_db_error){ |
| const __db_err = wasm.xWrap( |
| 'sqlite3__wasm_db_error', 'int', 'sqlite3*', 'int', 'string' |
| ); |
| /** |
| Sets the given db's error state. Accepts: |
| |
| - (sqlite3*, int code, string msg) |
| - (sqlite3*, Error e [,string msg = ''+e]) |
| |
| If passed a WasmAllocError, the message is ignored and the |
| result code is SQLITE_NOMEM. If passed any other Error type, |
| the result code defaults to SQLITE_ERROR unless the Error |
| object has a resultCode property, in which case that is used |
| (e.g. SQLite3Error has that). If passed a non-WasmAllocError |
| exception, the message string defaults to theError.message. |
| |
| Returns the resulting code. Pass (pDb,0,0) to clear the error |
| state. |
| */ |
| util.sqlite3__wasm_db_error = function(pDb, resultCode, message){ |
| if(resultCode instanceof sqlite3.WasmAllocError){ |
| resultCode = capi.SQLITE_NOMEM; |
| message = 0 /*avoid allocating message string*/; |
| }else if(resultCode instanceof Error){ |
| message = message || ''+resultCode; |
| resultCode = (resultCode.resultCode || capi.SQLITE_ERROR); |
| } |
| return pDb ? __db_err(pDb, resultCode, message) : resultCode; |
| }; |
| }else{ |
| util.sqlite3__wasm_db_error = function(pDb,errCode,msg){ |
| console.warn("sqlite3__wasm_db_error() is not exported.",arguments); |
| return errCode; |
| }; |
| } |
| }/*xWrap() bindings*/ |
| |
| {/* Import C-level constants and structs... */ |
| const cJson = wasm.xCall('sqlite3__wasm_enum_json'); |
| if(!cJson){ |
| toss("Maintenance required: increase sqlite3__wasm_enum_json()'s", |
| "static buffer size!"); |
| } |
| //console.debug('wasm.ctype length =',wasm.cstrlen(cJson)); |
| wasm.ctype = JSON.parse(wasm.cstrToJs(cJson)); |
| // Groups of SQLITE_xyz macros... |
| const defineGroups = ['access', 'authorizer', |
| 'blobFinalizers', 'changeset', |
| 'config', 'dataTypes', |
| 'dbConfig', 'dbStatus', |
| 'encodings', 'fcntl', 'flock', 'ioCap', |
| 'limits', 'openFlags', |
| 'prepareFlags', 'resultCodes', |
| 'sqlite3Status', |
| 'stmtStatus', 'syncFlags', |
| 'trace', 'txnState', 'udfFlags', |
| 'version' ]; |
| if(wasm.bigIntEnabled){ |
| defineGroups.push('serialize', 'session', 'vtab'); |
| } |
| for(const t of defineGroups){ |
| for(const e of Object.entries(wasm.ctype[t])){ |
| // ^^^ [k,v] there triggers a buggy code transformation via |
| // one of the Emscripten-driven optimizers. |
| capi[e[0]] = e[1]; |
| } |
| } |
| if(!wasm.functionEntry(capi.SQLITE_WASM_DEALLOC)){ |
| toss("Internal error: cannot resolve exported function", |
| "entry SQLITE_WASM_DEALLOC (=="+capi.SQLITE_WASM_DEALLOC+")."); |
| } |
| const __rcMap = Object.create(null); |
| for(const t of ['resultCodes']){ |
| for(const e of Object.entries(wasm.ctype[t])){ |
| __rcMap[e[1]] = e[0]; |
| } |
| } |
| /** |
| For the given integer, returns the SQLITE_xxx result code as a |
| string, or undefined if no such mapping is found. |
| */ |
| capi.sqlite3_js_rc_str = (rc)=>__rcMap[rc]; |
| /* Bind all registered C-side structs... */ |
| const notThese = Object.assign(Object.create(null),{ |
| // For each struct to NOT register, map its name to true: |
| WasmTestStruct: true, |
| /* We unregister the kvvfs VFS from Worker threads below. */ |
| sqlite3_kvvfs_methods: !util.isUIThread(), |
| /* sqlite3_index_info and friends require int64: */ |
| sqlite3_index_info: !wasm.bigIntEnabled, |
| sqlite3_index_constraint: !wasm.bigIntEnabled, |
| sqlite3_index_orderby: !wasm.bigIntEnabled, |
| sqlite3_index_constraint_usage: !wasm.bigIntEnabled |
| }); |
| for(const s of wasm.ctype.structs){ |
| if(!notThese[s.name]){ |
| capi[s.name] = sqlite3.StructBinder(s); |
| } |
| } |
| if(capi.sqlite3_index_info){ |
| /* Move these inner structs into sqlite3_index_info. Binding |
| ** them to WASM requires that we create global-scope structs to |
| ** model them with, but those are no longer needed after we've |
| ** passed them to StructBinder. */ |
| for(const k of ['sqlite3_index_constraint', |
| 'sqlite3_index_orderby', |
| 'sqlite3_index_constraint_usage']){ |
| capi.sqlite3_index_info[k] = capi[k]; |
| delete capi[k]; |
| } |
| capi.sqlite3_vtab_config = wasm.xWrap( |
| 'sqlite3__wasm_vtab_config','int',[ |
| 'sqlite3*', 'int', 'int'] |
| ); |
| }/* end vtab-related setup */ |
| }/*end C constant and struct imports*/ |
| |
| /** |
| Internal helper to assist in validating call argument counts in |
| the hand-written sqlite3_xyz() wrappers. We do this only for |
| consistency with non-special-case wrappings. |
| */ |
| const __dbArgcMismatch = (pDb,f,n)=>{ |
| return util.sqlite3__wasm_db_error(pDb, capi.SQLITE_MISUSE, |
| f+"() requires "+n+" argument"+ |
| (1===n?"":'s')+"."); |
| }; |
| |
| /** Code duplication reducer for functions which take an encoding |
| argument and require SQLITE_UTF8. Sets the db error code to |
| SQLITE_FORMAT, installs a descriptive error message, |
| and returns SQLITE_FORMAT. */ |
| const __errEncoding = (pDb)=>{ |
| return util.sqlite3__wasm_db_error( |
| pDb, capi.SQLITE_FORMAT, "SQLITE_UTF8 is the only supported encoding." |
| ); |
| }; |
| |
| /** |
| __dbCleanupMap is infrastructure for recording registration of |
| UDFs and collations so that sqlite3_close_v2() can clean up any |
| automated JS-to-WASM function conversions installed by those. |
| */ |
| const __argPDb = (pDb)=>wasm.xWrap.argAdapter('sqlite3*')(pDb); |
| const __argStr = (str)=>wasm.isPtr(str) ? wasm.cstrToJs(str) : str; |
| const __dbCleanupMap = function( |
| pDb, mode/*0=remove, >0=create if needed, <0=do not create if missing*/ |
| ){ |
| pDb = __argPDb(pDb); |
| let m = this.dbMap.get(pDb); |
| if(!mode){ |
| this.dbMap.delete(pDb); |
| return m; |
| }else if(!m && mode>0){ |
| this.dbMap.set(pDb, (m = Object.create(null))); |
| } |
| return m; |
| }.bind(Object.assign(Object.create(null),{ |
| dbMap: new Map |
| })); |
| |
| __dbCleanupMap.addCollation = function(pDb, name){ |
| const m = __dbCleanupMap(pDb, 1); |
| if(!m.collation) m.collation = new Set; |
| m.collation.add(__argStr(name).toLowerCase()); |
| }; |
| |
| __dbCleanupMap._addUDF = function(pDb, name, arity, map){ |
| /* Map UDF name to a Set of arity values */ |
| name = __argStr(name).toLowerCase(); |
| let u = map.get(name); |
| if(!u) map.set(name, (u = new Set)); |
| u.add((arity<0) ? -1 : arity); |
| }; |
| |
| __dbCleanupMap.addFunction = function(pDb, name, arity){ |
| const m = __dbCleanupMap(pDb, 1); |
| if(!m.udf) m.udf = new Map; |
| this._addUDF(pDb, name, arity, m.udf); |
| }; |
| |
| if( wasm.exports.sqlite3_create_window_function ){ |
| __dbCleanupMap.addWindowFunc = function(pDb, name, arity){ |
| const m = __dbCleanupMap(pDb, 1); |
| if(!m.wudf) m.wudf = new Map; |
| this._addUDF(pDb, name, arity, m.wudf); |
| }; |
| } |
| |
| /** |
| Intended to be called _only_ from sqlite3_close_v2(), |
| passed its non-0 db argument. |
| |
| This function frees up certain automatically-installed WASM |
| function bindings which were installed on behalf of the given db, |
| as those may otherwise leak. |
| |
| Notable caveat: this is only ever run via |
| sqlite3.capi.sqlite3_close_v2(). If a client, for whatever |
| reason, uses sqlite3.wasm.exports.sqlite3_close_v2() (the |
| function directly exported from WASM), this cleanup will not |
| happen. |
| |
| This is not a silver bullet for avoiding automation-related |
| leaks but represents "an honest effort." |
| |
| The issue being addressed here is covered at: |
| |
| https://sqlite.org/wasm/doc/trunk/api-c-style.md#convert-func-ptr |
| */ |
| __dbCleanupMap.cleanup = function(pDb){ |
| pDb = __argPDb(pDb); |
| //wasm.xWrap.FuncPtrAdapter.debugFuncInstall = false; |
| /** |
| Installing NULL functions in the C API will remove those |
| bindings. The FuncPtrAdapter which sits between us and the C |
| API will also treat that as an opportunity to |
| wasm.uninstallFunction() any WASM function bindings it has |
| installed for pDb. |
| */ |
| const closeArgs = [pDb]; |
| for(const name of [ |
| 'sqlite3_busy_handler', |
| 'sqlite3_commit_hook', |
| 'sqlite3_preupdate_hook', |
| 'sqlite3_progress_handler', |
| 'sqlite3_rollback_hook', |
| 'sqlite3_set_authorizer', |
| 'sqlite3_trace_v2', |
| 'sqlite3_update_hook' |
| ]) { |
| const x = wasm.exports[name]; |
| if( !x ){ |
| /* assume it was built without this API */ |
| continue; |
| } |
| closeArgs.length = x.length/*==argument count*/ |
| /* recall that undefined entries translate to 0 when passed to |
| WASM. */; |
| try{ capi[name](...closeArgs) } |
| catch(e){ |
| sqlite3.config.warn("close-time call of",name+"(",closeArgs,") threw:",e); |
| } |
| } |
| const m = __dbCleanupMap(pDb, 0); |
| if(!m) return; |
| if(m.collation){ |
| for(const name of m.collation){ |
| try{ |
| capi.sqlite3_create_collation_v2( |
| pDb, name, capi.SQLITE_UTF8, 0, 0, 0 |
| ); |
| }catch(e){ |
| /*ignored*/ |
| } |
| } |
| delete m.collation; |
| } |
| let i; |
| for(i = 0; i < 2; ++i){ /* Clean up UDFs... */ |
| const fmap = i ? m.wudf : m.udf; |
| if(!fmap) continue; |
| const func = i |
| ? capi.sqlite3_create_window_function |
| : capi.sqlite3_create_function_v2; |
| for(const e of fmap){ |
| const name = e[0], arities = e[1]; |
| const fargs = [pDb, name, 0/*arity*/, capi.SQLITE_UTF8, 0, 0, 0, 0, 0]; |
| if(i) fargs.push(0); |
| for(const arity of arities){ |
| try{ fargs[2] = arity; func.apply(null, fargs); } |
| catch(e){/*ignored*/} |
| } |
| arities.clear(); |
| } |
| fmap.clear(); |
| } |
| delete m.udf; |
| delete m.wudf; |
| }/*__dbCleanupMap.cleanup()*/; |
| |
| {/* Binding of sqlite3_close_v2() */ |
| const __sqlite3CloseV2 = wasm.xWrap("sqlite3_close_v2", "int", "sqlite3*"); |
| capi.sqlite3_close_v2 = function(pDb){ |
| if(1!==arguments.length) return __dbArgcMismatch(pDb, 'sqlite3_close_v2', 1); |
| if(pDb){ |
| try{__dbCleanupMap.cleanup(pDb)} catch(e){/*ignored*/} |
| } |
| return __sqlite3CloseV2(pDb); |
| }; |
| }/*sqlite3_close_v2()*/ |
| |
| if(capi.sqlite3session_create){ |
| const __sqlite3SessionDelete = wasm.xWrap( |
| 'sqlite3session_delete', undefined, ['sqlite3_session*'] |
| ); |
| capi.sqlite3session_delete = function(pSession){ |
| if(1!==arguments.length){ |
| return __dbArgcMismatch(pDb, 'sqlite3session_delete', 1); |
| /* Yes, we're returning a value from a void function. That seems |
| like the lesser evil compared to not maintaining arg-count |
| consistency as we do with other similar bindings. */ |
| } |
| else if(pSession){ |
| //wasm.xWrap.FuncPtrAdapter.debugFuncInstall = true; |
| capi.sqlite3session_table_filter(pSession, 0, 0); |
| } |
| __sqlite3SessionDelete(pSession); |
| }; |
| } |
| |
| {/* Bindings for sqlite3_create_collation[_v2]() */ |
| // contextKey() impl for wasm.xWrap.FuncPtrAdapter |
| const contextKey = (argv,argIndex)=>{ |
| return 'argv['+argIndex+']:'+argv[0/* sqlite3* */]+ |
| ':'+wasm.cstrToJs(argv[1/* collation name */]).toLowerCase() |
| }; |
| const __sqlite3CreateCollationV2 = wasm.xWrap( |
| 'sqlite3_create_collation_v2', 'int', [ |
| 'sqlite3*', 'string', 'int', '*', |
| new wasm.xWrap.FuncPtrAdapter({ |
| /* int(*xCompare)(void*,int,const void*,int,const void*) */ |
| name: 'xCompare', signature: 'i(pipip)', contextKey |
| }), |
| new wasm.xWrap.FuncPtrAdapter({ |
| /* void(*xDestroy(void*) */ |
| name: 'xDestroy', signature: 'v(p)', contextKey |
| }) |
| ] |
| ); |
| |
| /** |
| Works exactly like C's sqlite3_create_collation_v2() except that: |
| |
| 1) It returns capi.SQLITE_FORMAT if the 3rd argument contains |
| any encoding-related value other than capi.SQLITE_UTF8. No |
| other encodings are supported. As a special case, if the |
| bottom 4 bits of that argument are 0, SQLITE_UTF8 is |
| assumed. |
| |
| 2) It accepts JS functions for its function-pointer arguments, |
| for which it will install WASM-bound proxies. The bindings |
| are "permanent," in that they will stay in the WASM environment |
| until it shuts down unless the client calls this again with the |
| same collation name and a value of 0 or null for the |
| the function pointer(s). |
| |
| For consistency with the C API, it requires the same number of |
| arguments. It returns capi.SQLITE_MISUSE if passed any other |
| argument count. |
| |
| Returns 0 on success, non-0 on error, in which case the error |
| state of pDb (of type `sqlite3*` or argument-convertible to it) |
| may contain more information. |
| */ |
| capi.sqlite3_create_collation_v2 = function(pDb,zName,eTextRep,pArg,xCompare,xDestroy){ |
| if(6!==arguments.length) return __dbArgcMismatch(pDb, 'sqlite3_create_collation_v2', 6); |
| else if( 0 === (eTextRep & 0xf) ){ |
| eTextRep |= capi.SQLITE_UTF8; |
| }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){ |
| return __errEncoding(pDb); |
| } |
| try{ |
| const rc = __sqlite3CreateCollationV2(pDb, zName, eTextRep, pArg, xCompare, xDestroy); |
| if(0===rc && xCompare instanceof Function){ |
| __dbCleanupMap.addCollation(pDb, zName); |
| } |
| return rc; |
| }catch(e){ |
| return util.sqlite3__wasm_db_error(pDb, e); |
| } |
| }; |
| |
| capi.sqlite3_create_collation = (pDb,zName,eTextRep,pArg,xCompare)=>{ |
| return (5===arguments.length) |
| ? capi.sqlite3_create_collation_v2(pDb,zName,eTextRep,pArg,xCompare,0) |
| : __dbArgcMismatch(pDb, 'sqlite3_create_collation', 5); |
| }; |
| |
| }/*sqlite3_create_collation() and friends*/ |
| |
| {/* Special-case handling of sqlite3_create_function_v2() |
| and sqlite3_create_window_function(). */ |
| /** FuncPtrAdapter for contextKey() for sqlite3_create_function() |
| and friends. */ |
| const contextKey = function(argv,argIndex){ |
| return ( |
| argv[0/* sqlite3* */] |
| +':'+(argv[2/*number of UDF args*/] < 0 ? -1 : argv[2]) |
| +':'+argIndex/*distinct for each xAbc callback type*/ |
| +':'+wasm.cstrToJs(argv[1]).toLowerCase() |
| ) |
| }; |
| |
| /** |
| JS proxies for the various sqlite3_create[_window]_function() |
| callbacks, structured in a form usable by wasm.xWrap.FuncPtrAdapter. |
| */ |
| const __cfProxy = Object.assign(Object.create(null), { |
| xInverseAndStep: { |
| signature:'v(pip)', contextKey, |
| callProxy: (callback)=>{ |
| return (pCtx, argc, pArgv)=>{ |
| try{ callback(pCtx, ...capi.sqlite3_values_to_js(argc, pArgv)) } |
| catch(e){ capi.sqlite3_result_error_js(pCtx, e) } |
| }; |
| } |
| }, |
| xFinalAndValue: { |
| signature:'v(p)', contextKey, |
| callProxy: (callback)=>{ |
| return (pCtx)=>{ |
| try{ capi.sqlite3_result_js(pCtx, callback(pCtx)) } |
| catch(e){ capi.sqlite3_result_error_js(pCtx, e) } |
| }; |
| } |
| }, |
| xFunc: { |
| signature:'v(pip)', contextKey, |
| callProxy: (callback)=>{ |
| return (pCtx, argc, pArgv)=>{ |
| try{ |
| capi.sqlite3_result_js( |
| pCtx, |
| callback(pCtx, ...capi.sqlite3_values_to_js(argc, pArgv)) |
| ); |
| }catch(e){ |
| //console.error('xFunc() caught:',e); |
| capi.sqlite3_result_error_js(pCtx, e); |
| } |
| }; |
| } |
| }, |
| xDestroy: { |
| signature:'v(p)', contextKey, |
| //Arguable: a well-behaved destructor doesn't require a proxy. |
| callProxy: (callback)=>{ |
| return (pVoid)=>{ |
| try{ callback(pVoid) } |
| catch(e){ console.error("UDF xDestroy method threw:",e) } |
| }; |
| } |
| } |
| })/*__cfProxy*/; |
| |
| const __sqlite3CreateFunction = wasm.xWrap( |
| "sqlite3_create_function_v2", "int", [ |
| "sqlite3*", "string"/*funcName*/, "int"/*nArg*/, |
| "int"/*eTextRep*/, "*"/*pApp*/, |
| new wasm.xWrap.FuncPtrAdapter({name: 'xFunc', ...__cfProxy.xFunc}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xStep', ...__cfProxy.xInverseAndStep}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xFinal', ...__cfProxy.xFinalAndValue}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xDestroy', ...__cfProxy.xDestroy}) |
| ] |
| ); |
| |
| const __sqlite3CreateWindowFunction = |
| wasm.exports.sqlite3_create_window_function |
| ? wasm.xWrap( |
| "sqlite3_create_window_function", "int", [ |
| "sqlite3*", "string"/*funcName*/, "int"/*nArg*/, |
| "int"/*eTextRep*/, "*"/*pApp*/, |
| new wasm.xWrap.FuncPtrAdapter({name: 'xStep', ...__cfProxy.xInverseAndStep}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xFinal', ...__cfProxy.xFinalAndValue}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xValue', ...__cfProxy.xFinalAndValue}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xInverse', ...__cfProxy.xInverseAndStep}), |
| new wasm.xWrap.FuncPtrAdapter({name: 'xDestroy', ...__cfProxy.xDestroy}) |
| ] |
| ) |
| : undefined; |
| |
| /* Documented in the api object's initializer. */ |
| capi.sqlite3_create_function_v2 = function f( |
| pDb, funcName, nArg, eTextRep, pApp, |
| xFunc, //void (*xFunc)(sqlite3_context*,int,sqlite3_value**) |
| xStep, //void (*xStep)(sqlite3_context*,int,sqlite3_value**) |
| xFinal, //void (*xFinal)(sqlite3_context*) |
| xDestroy //void (*xDestroy)(void*) |
| ){ |
| if( f.length!==arguments.length ){ |
| return __dbArgcMismatch(pDb,"sqlite3_create_function_v2",f.length); |
| }else if( 0 === (eTextRep & 0xf) ){ |
| eTextRep |= capi.SQLITE_UTF8; |
| }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){ |
| return __errEncoding(pDb); |
| } |
| try{ |
| const rc = __sqlite3CreateFunction(pDb, funcName, nArg, eTextRep, |
| pApp, xFunc, xStep, xFinal, xDestroy); |
| if(0===rc && (xFunc instanceof Function |
| || xStep instanceof Function |
| || xFinal instanceof Function |
| || xDestroy instanceof Function)){ |
| __dbCleanupMap.addFunction(pDb, funcName, nArg); |
| } |
| return rc; |
| }catch(e){ |
| console.error("sqlite3_create_function_v2() setup threw:",e); |
| return util.sqlite3__wasm_db_error(pDb, e, "Creation of UDF threw: "+e); |
| } |
| }; |
| |
| /* Documented in the api object's initializer. */ |
| capi.sqlite3_create_function = function f( |
| pDb, funcName, nArg, eTextRep, pApp, |
| xFunc, xStep, xFinal |
| ){ |
| return (f.length===arguments.length) |
| ? capi.sqlite3_create_function_v2(pDb, funcName, nArg, eTextRep, |
| pApp, xFunc, xStep, xFinal, 0) |
| : __dbArgcMismatch(pDb,"sqlite3_create_function",f.length); |
| }; |
| |
| /* Documented in the api object's initializer. */ |
| if( __sqlite3CreateWindowFunction ){ |
| capi.sqlite3_create_window_function = function f( |
| pDb, funcName, nArg, eTextRep, pApp, |
| xStep, //void (*xStep)(sqlite3_context*,int,sqlite3_value**) |
| xFinal, //void (*xFinal)(sqlite3_context*) |
| xValue, //void (*xValue)(sqlite3_context*) |
| xInverse,//void (*xInverse)(sqlite3_context*,int,sqlite3_value**) |
| xDestroy //void (*xDestroy)(void*) |
| ){ |
| if( f.length!==arguments.length ){ |
| return __dbArgcMismatch(pDb,"sqlite3_create_window_function",f.length); |
| }else if( 0 === (eTextRep & 0xf) ){ |
| eTextRep |= capi.SQLITE_UTF8; |
| }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){ |
| return __errEncoding(pDb); |
| } |
| try{ |
| const rc = __sqlite3CreateWindowFunction(pDb, funcName, nArg, eTextRep, |
| pApp, xStep, xFinal, xValue, |
| xInverse, xDestroy); |
| if(0===rc && (xStep instanceof Function |
| || xFinal instanceof Function |
| || xValue instanceof Function |
| || xInverse instanceof Function |
| || xDestroy instanceof Function)){ |
| __dbCleanupMap.addWindowFunc(pDb, funcName, nArg); |
| } |
| return rc; |
| }catch(e){ |
| console.error("sqlite3_create_window_function() setup threw:",e); |
| return util.sqlite3__wasm_db_error(pDb, e, "Creation of UDF threw: "+e); |
| } |
| }; |
| }else{ |
| delete capi.sqlite3_create_window_function; |
| } |
| /** |
| A _deprecated_ alias for capi.sqlite3_result_js() which |
| predates the addition of that function in the public API. |
| */ |
| capi.sqlite3_create_function_v2.udfSetResult = |
| capi.sqlite3_create_function.udfSetResult = capi.sqlite3_result_js; |
| if(capi.sqlite3_create_window_function){ |
| capi.sqlite3_create_window_function.udfSetResult = capi.sqlite3_result_js; |
| } |
| |
| /** |
| A _deprecated_ alias for capi.sqlite3_values_to_js() which |
| predates the addition of that function in the public API. |
| */ |
| capi.sqlite3_create_function_v2.udfConvertArgs = |
| capi.sqlite3_create_function.udfConvertArgs = capi.sqlite3_values_to_js; |
| if(capi.sqlite3_create_window_function){ |
| capi.sqlite3_create_window_function.udfConvertArgs = capi.sqlite3_values_to_js; |
| } |
| |
| /** |
| A _deprecated_ alias for capi.sqlite3_result_error_js() which |
| predates the addition of that function in the public API. |
| */ |
| capi.sqlite3_create_function_v2.udfSetError = |
| capi.sqlite3_create_function.udfSetError = capi.sqlite3_result_error_js; |
| if(capi.sqlite3_create_window_function){ |
| capi.sqlite3_create_window_function.udfSetError = capi.sqlite3_result_error_js; |
| } |
| |
| }/*sqlite3_create_function_v2() and sqlite3_create_window_function() proxies*/; |
| |
| {/* Special-case handling of sqlite3_prepare_v2() and |
| sqlite3_prepare_v3() */ |
| |
| /** |
| Helper for string:flexible conversions which require a |
| byte-length counterpart argument. Passed a value and its |
| ostensible length, this function returns [V,N], where V is |
| either v or a transformed copy of v and N is either n, -1, or |
| the byte length of v (if it's a byte array or ArrayBuffer). |
| */ |
| const __flexiString = (v,n)=>{ |
| if('string'===typeof v){ |
| n = -1; |
| }else if(util.isSQLableTypedArray(v)){ |
| n = v.byteLength; |
| v = util.typedArrayToString( |
| (v instanceof ArrayBuffer) ? new Uint8Array(v) : v |
| ); |
| }else if(Array.isArray(v)){ |
| v = v.join(""); |
| n = -1; |
| } |
| return [v, n]; |
| }; |
| |
| /** |
| Scope-local holder of the two impls of sqlite3_prepare_v2/v3(). |
| */ |
| const __prepare = { |
| /** |
| This binding expects a JS string as its 2nd argument and |
| null as its final argument. In order to compile multiple |
| statements from a single string, the "full" impl (see |
| below) must be used. |
| */ |
| basic: wasm.xWrap('sqlite3_prepare_v3', |
| "int", ["sqlite3*", "string", |
| "int"/*ignored for this impl!*/, |
| "int", "**", |
| "**"/*MUST be 0 or null or undefined!*/]), |
| /** |
| Impl which requires that the 2nd argument be a pointer |
| to the SQL string, instead of being converted to a |
| string. This variant is necessary for cases where we |
| require a non-NULL value for the final argument |
| (exec()'ing multiple statements from one input |
| string). For simpler cases, where only the first |
| statement in the SQL string is required, the wrapper |
| named sqlite3_prepare_v2() is sufficient and easier to |
| use because it doesn't require dealing with pointers. |
| */ |
| full: wasm.xWrap('sqlite3_prepare_v3', |
| "int", ["sqlite3*", "*", "int", "int", |
| "**", "**"]) |
| }; |
| |
| /* Documented in the capi object's initializer. */ |
| capi.sqlite3_prepare_v3 = function f(pDb, sql, sqlLen, prepFlags, ppStmt, pzTail){ |
| if(f.length!==arguments.length){ |
| return __dbArgcMismatch(pDb,"sqlite3_prepare_v3",f.length); |
| } |
| const [xSql, xSqlLen] = __flexiString(sql, sqlLen); |
| switch(typeof xSql){ |
| case 'string': return __prepare.basic(pDb, xSql, xSqlLen, prepFlags, ppStmt, null); |
| case 'number': return __prepare.full(pDb, xSql, xSqlLen, prepFlags, ppStmt, pzTail); |
| default: |
| return util.sqlite3__wasm_db_error( |
| pDb, capi.SQLITE_MISUSE, |
| "Invalid SQL argument type for sqlite3_prepare_v2/v3()." |
| ); |
| } |
| }; |
| |
| /* Documented in the capi object's initializer. */ |
| capi.sqlite3_prepare_v2 = function f(pDb, sql, sqlLen, ppStmt, pzTail){ |
| return (f.length===arguments.length) |
| ? capi.sqlite3_prepare_v3(pDb, sql, sqlLen, 0, ppStmt, pzTail) |
| : __dbArgcMismatch(pDb,"sqlite3_prepare_v2",f.length); |
| }; |
| |
| }/*sqlite3_prepare_v2/v3()*/ |
| |
| {/*sqlite3_bind_text/blob()*/ |
| const __bindText = wasm.xWrap("sqlite3_bind_text", "int", [ |
| "sqlite3_stmt*", "int", "string", "int", "*" |
| ]); |
| const __bindBlob = wasm.xWrap("sqlite3_bind_blob", "int", [ |
| "sqlite3_stmt*", "int", "*", "int", "*" |
| ]); |
| |
| /** Documented in the capi object's initializer. */ |
| capi.sqlite3_bind_text = function f(pStmt, iCol, text, nText, xDestroy){ |
| if(f.length!==arguments.length){ |
| return __dbArgcMismatch(capi.sqlite3_db_handle(pStmt), |
| "sqlite3_bind_text", f.length); |
| }else if(wasm.isPtr(text) || null===text){ |
| return __bindText(pStmt, iCol, text, nText, xDestroy); |
| }else if(text instanceof ArrayBuffer){ |
| text = new Uint8Array(text); |
| }else if(Array.isArray(pMem)){ |
| text = pMem.join(''); |
| } |
| let p, n; |
| try{ |
| if(util.isSQLableTypedArray(text)){ |
| p = wasm.allocFromTypedArray(text); |
| n = text.byteLength; |
| }else if('string'===typeof text){ |
| [p, n] = wasm.allocCString(text); |
| }else{ |
| return util.sqlite3__wasm_db_error( |
| capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE, |
| "Invalid 3rd argument type for sqlite3_bind_text()." |
| ); |
| } |
| return __bindText(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC); |
| }catch(e){ |
| wasm.dealloc(p); |
| return util.sqlite3__wasm_db_error( |
| capi.sqlite3_db_handle(pStmt), e |
| ); |
| } |
| }/*sqlite3_bind_text()*/; |
| |
| /** Documented in the capi object's initializer. */ |
| capi.sqlite3_bind_blob = function f(pStmt, iCol, pMem, nMem, xDestroy){ |
| if(f.length!==arguments.length){ |
| return __dbArgcMismatch(capi.sqlite3_db_handle(pStmt), |
| "sqlite3_bind_blob", f.length); |
| }else if(wasm.isPtr(pMem) || null===pMem){ |
| return __bindBlob(pStmt, iCol, pMem, nMem, xDestroy); |
| }else if(pMem instanceof ArrayBuffer){ |
| pMem = new Uint8Array(pMem); |
| }else if(Array.isArray(pMem)){ |
| pMem = pMem.join(''); |
| } |
| let p, n; |
| try{ |
| if(util.isBindableTypedArray(pMem)){ |
| p = wasm.allocFromTypedArray(pMem); |
| n = nMem>=0 ? nMem : pMem.byteLength; |
| }else if('string'===typeof pMem){ |
| [p, n] = wasm.allocCString(pMem); |
| }else{ |
| return util.sqlite3__wasm_db_error( |
| capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE, |
| "Invalid 3rd argument type for sqlite3_bind_blob()." |
| ); |
| } |
| return __bindBlob(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC); |
| }catch(e){ |
| wasm.dealloc(p); |
| return util.sqlite3__wasm_db_error( |
| capi.sqlite3_db_handle(pStmt), e |
| ); |
| } |
| }/*sqlite3_bind_blob()*/; |
| |
| }/*sqlite3_bind_text/blob()*/ |
| |
| {/* sqlite3_config() */ |
| /** |
| Wraps a small subset of the C API's sqlite3_config() options. |
| Unsupported options trigger the return of capi.SQLITE_NOTFOUND. |
| Passing fewer than 2 arguments triggers return of |
| capi.SQLITE_MISUSE. |
| */ |
| capi.sqlite3_config = function(op, ...args){ |
| if(arguments.length<2) return capi.SQLITE_MISUSE; |
| switch(op){ |
| case capi.SQLITE_CONFIG_COVERING_INDEX_SCAN: // 20 /* int */ |
| case capi.SQLITE_CONFIG_MEMSTATUS:// 9 /* boolean */ |
| case capi.SQLITE_CONFIG_SMALL_MALLOC: // 27 /* boolean */ |
| case capi.SQLITE_CONFIG_SORTERREF_SIZE: // 28 /* int nByte */ |
| case capi.SQLITE_CONFIG_STMTJRNL_SPILL: // 26 /* int nByte */ |
| case capi.SQLITE_CONFIG_URI:// 17 /* int */ |
| return wasm.exports.sqlite3__wasm_config_i(op, args[0]); |
| case capi.SQLITE_CONFIG_LOOKASIDE: // 13 /* int int */ |
| return wasm.exports.sqlite3__wasm_config_ii(op, args[0], args[1]); |
| case capi.SQLITE_CONFIG_MEMDB_MAXSIZE: // 29 /* sqlite3_int64 */ |
| return wasm.exports.sqlite3__wasm_config_j(op, args[0]); |
| case capi.SQLITE_CONFIG_GETMALLOC: // 5 /* sqlite3_mem_methods* */ |
| case capi.SQLITE_CONFIG_GETMUTEX: // 11 /* sqlite3_mutex_methods* */ |
| case capi.SQLITE_CONFIG_GETPCACHE2: // 19 /* sqlite3_pcache_methods2* */ |
| case capi.SQLITE_CONFIG_GETPCACHE: // 15 /* no-op */ |
| case capi.SQLITE_CONFIG_HEAP: // 8 /* void*, int nByte, int min */ |
| case capi.SQLITE_CONFIG_LOG: // 16 /* xFunc, void* */ |
| case capi.SQLITE_CONFIG_MALLOC:// 4 /* sqlite3_mem_methods* */ |
| case capi.SQLITE_CONFIG_MMAP_SIZE: // 22 /* sqlite3_int64, sqlite3_int64 */ |
| case capi.SQLITE_CONFIG_MULTITHREAD: // 2 /* nil */ |
| case capi.SQLITE_CONFIG_MUTEX: // 10 /* sqlite3_mutex_methods* */ |
| case capi.SQLITE_CONFIG_PAGECACHE: // 7 /* void*, int sz, int N */ |
| case capi.SQLITE_CONFIG_PCACHE2: // 18 /* sqlite3_pcache_methods2* */ |
| case capi.SQLITE_CONFIG_PCACHE: // 14 /* no-op */ |
| case capi.SQLITE_CONFIG_PCACHE_HDRSZ: // 24 /* int *psz */ |
| case capi.SQLITE_CONFIG_PMASZ: // 25 /* unsigned int szPma */ |
| case capi.SQLITE_CONFIG_SERIALIZED: // 3 /* nil */ |
| case capi.SQLITE_CONFIG_SINGLETHREAD: // 1 /* nil */: |
| case capi.SQLITE_CONFIG_SQLLOG: // 21 /* xSqllog, void* */ |
| case capi.SQLITE_CONFIG_WIN32_HEAPSIZE: // 23 /* int nByte */ |
| default: |
| /* maintenance note: we specifically do not include |
| SQLITE_CONFIG_ROWID_IN_VIEW here, on the grounds that |
| it's only for legacy support and no apps written with |
| this API require that. */ |
| return capi.SQLITE_NOTFOUND; |
| } |
| }; |
| }/* sqlite3_config() */ |
| |
| {/*auto-extension bindings.*/ |
| const __autoExtFptr = new Set; |
| |
| capi.sqlite3_auto_extension = function(fPtr){ |
| if( fPtr instanceof Function ){ |
| fPtr = wasm.installFunction('i(ppp)', fPtr); |
| }else if( 1!==arguments.length || !wasm.isPtr(fPtr) ){ |
| return capi.SQLITE_MISUSE; |
| } |
| const rc = wasm.exports.sqlite3_auto_extension(fPtr); |
| if( fPtr!==arguments[0] ){ |
| if(0===rc) __autoExtFptr.add(fPtr); |
| else wasm.uninstallFunction(fPtr); |
| } |
| return rc; |
| }; |
| |
| capi.sqlite3_cancel_auto_extension = function(fPtr){ |
| /* We do not do an automatic JS-to-WASM function conversion here |
| because it would be senseless: the converted pointer would |
| never possibly match an already-installed one. */; |
| if(!fPtr || 1!==arguments.length || !wasm.isPtr(fPtr)) return 0; |
| return wasm.exports.sqlite3_cancel_auto_extension(fPtr); |
| /* Note that it "cannot happen" that a client passes a pointer which |
| is in __autoExtFptr because __autoExtFptr only contains automatic |
| conversions created inside sqlite3_auto_extension() and |
| never exposed to the client. */ |
| }; |
| |
| capi.sqlite3_reset_auto_extension = function(){ |
| wasm.exports.sqlite3_reset_auto_extension(); |
| for(const fp of __autoExtFptr) wasm.uninstallFunction(fp); |
| __autoExtFptr.clear(); |
| }; |
| }/* auto-extension */ |
| |
| const pKvvfs = capi.sqlite3_vfs_find("kvvfs"); |
| if( pKvvfs ){/* kvvfs-specific glue */ |
| if(util.isUIThread()){ |
| const kvvfsMethods = new capi.sqlite3_kvvfs_methods( |
| wasm.exports.sqlite3__wasm_kvvfs_methods() |
| ); |
| delete capi.sqlite3_kvvfs_methods; |
| |
| const kvvfsMakeKey = wasm.exports.sqlite3__wasm_kvvfsMakeKeyOnPstack, |
| pstack = wasm.pstack; |
| |
| const kvvfsStorage = (zClass)=> |
| ((115/*=='s'*/===wasm.peek(zClass)) |
| ? sessionStorage : localStorage); |
| |
| /** |
| Implementations for members of the object referred to by |
| sqlite3__wasm_kvvfs_methods(). We swap out the native |
| implementations with these, which use localStorage or |
| sessionStorage for their backing store. |
| */ |
| const kvvfsImpls = { |
| xRead: (zClass, zKey, zBuf, nBuf)=>{ |
| const stack = pstack.pointer, |
| astack = wasm.scopedAllocPush(); |
| try { |
| const zXKey = kvvfsMakeKey(zClass,zKey); |
| if(!zXKey) return -3/*OOM*/; |
| const jKey = wasm.cstrToJs(zXKey); |
| const jV = kvvfsStorage(zClass).getItem(jKey); |
| if(!jV) return -1; |
| const nV = jV.length /* Note that we are relying 100% on v being |
| ASCII so that jV.length is equal to the |
| C-string's byte length. */; |
| if(nBuf<=0) return nV; |
| else if(1===nBuf){ |
| wasm.poke(zBuf, 0); |
| return nV; |
| } |
| const zV = wasm.scopedAllocCString(jV); |
| if(nBuf > nV + 1) nBuf = nV + 1; |
| wasm.heap8u().copyWithin(zBuf, zV, zV + nBuf - 1); |
| wasm.poke(zBuf + nBuf - 1, 0); |
| return nBuf - 1; |
| }catch(e){ |
| console.error("kvstorageRead()",e); |
| return -2; |
| }finally{ |
| pstack.restore(stack); |
| wasm.scopedAllocPop(astack); |
| } |
| }, |
| xWrite: (zClass, zKey, zData)=>{ |
| const stack = pstack.pointer; |
| try { |
| const zXKey = kvvfsMakeKey(zClass,zKey); |
| if(!zXKey) return 1/*OOM*/; |
| const jKey = wasm.cstrToJs(zXKey); |
| kvvfsStorage(zClass).setItem(jKey, wasm.cstrToJs(zData)); |
| return 0; |
| }catch(e){ |
| console.error("kvstorageWrite()",e); |
| return capi.SQLITE_IOERR; |
| }finally{ |
| pstack.restore(stack); |
| } |
| }, |
| xDelete: (zClass, zKey)=>{ |
| const stack = pstack.pointer; |
| try { |
| const zXKey = kvvfsMakeKey(zClass,zKey); |
| if(!zXKey) return 1/*OOM*/; |
| kvvfsStorage(zClass).removeItem(wasm.cstrToJs(zXKey)); |
| return 0; |
| }catch(e){ |
| console.error("kvstorageDelete()",e); |
| return capi.SQLITE_IOERR; |
| }finally{ |
| pstack.restore(stack); |
| } |
| } |
| }/*kvvfsImpls*/; |
| for(const k of Object.keys(kvvfsImpls)){ |
| kvvfsMethods[kvvfsMethods.memberKey(k)] = |
| wasm.installFunction( |
| kvvfsMethods.memberSignature(k), |
| kvvfsImpls[k] |
| ); |
| } |
| }else{ |
| /* Worker thread: unregister kvvfs to avoid it being used |
| for anything other than local/sessionStorage. It "can" |
| be used that way but it's not really intended to be. */ |
| capi.sqlite3_vfs_unregister(pKvvfs); |
| } |
| }/*pKvvfs*/ |
| |
| /* Warn if client-level code makes use of FuncPtrAdapter. */ |
| wasm.xWrap.FuncPtrAdapter.warnOnUse = true; |
| |
| const StructBinder = sqlite3.StructBinder |
| /* we require a local alias b/c StructBinder is removed from the sqlite3 |
| object during the final steps of the API cleanup. */; |
| /** |
| Installs a StructBinder-bound function pointer member of the |
| given name and function in the given StructBinder.StructType |
| target object. |
| |
| It creates a WASM proxy for the given function and arranges for |
| that proxy to be cleaned up when tgt.dispose() is called. Throws |
| on the slightest hint of error, e.g. tgt is-not-a StructType, |
| name does not map to a struct-bound member, etc. |
| |
| As a special case, if the given function is a pointer, then |
| `wasm.functionEntry()` is used to validate that it is a known |
| function. If so, it is used as-is with no extra level of proxying |
| or cleanup, else an exception is thrown. It is legal to pass a |
| value of 0, indicating a NULL pointer, with the caveat that 0 |
| _is_ a legal function pointer in WASM but it will not be accepted |
| as such _here_. (Justification: the function at address zero must |
| be one which initially came from the WASM module, not a method we |
| want to bind to a virtual table or VFS.) |
| |
| This function returns a proxy for itself which is bound to tgt |
| and takes 2 args (name,func). That function returns the same |
| thing as this one, permitting calls to be chained. |
| |
| If called with only 1 arg, it has no side effects but returns a |
| func with the same signature as described above. |
| |
| ACHTUNG: because we cannot generically know how to transform JS |
| exceptions into result codes, the installed functions do no |
| automatic catching of exceptions. It is critical, to avoid |
| undefined behavior in the C layer, that methods mapped via |
| this function do not throw. The exception, as it were, to that |
| rule is... |
| |
| If applyArgcCheck is true then each JS function (as opposed to |
| function pointers) gets wrapped in a proxy which asserts that it |
| is passed the expected number of arguments, throwing if the |
| argument count does not match expectations. That is only intended |
| for dev-time usage for sanity checking, and may leave the C |
| environment in an undefined state. |
| */ |
| const installMethod = function callee( |
| tgt, name, func, applyArgcCheck = callee.installMethodArgcCheck |
| ){ |
| if(!(tgt instanceof StructBinder.StructType)){ |
| toss("Usage error: target object is-not-a StructType."); |
| }else if(!(func instanceof Function) && !wasm.isPtr(func)){ |
| toss("Usage errror: expecting a Function or WASM pointer to one."); |
| } |
| if(1===arguments.length){ |
| return (n,f)=>callee(tgt, n, f, applyArgcCheck); |
| } |
| if(!callee.argcProxy){ |
| callee.argcProxy = function(tgt, funcName, func,sig){ |
| return function(...args){ |
| if(func.length!==arguments.length){ |
| toss("Argument mismatch for", |
| tgt.structInfo.name+"::"+funcName |
| +": Native signature is:",sig); |
| } |
| return func.apply(this, args); |
| } |
| }; |
| /* An ondispose() callback for use with |
| StructBinder-created types. */ |
| callee.removeFuncList = function(){ |
| if(this.ondispose.__removeFuncList){ |
| this.ondispose.__removeFuncList.forEach( |
| (v,ndx)=>{ |
| if('number'===typeof v){ |
| try{wasm.uninstallFunction(v)} |
| catch(e){/*ignore*/} |
| } |
| /* else it's a descriptive label for the next number in |
| the list. */ |
| } |
| ); |
| delete this.ondispose.__removeFuncList; |
| } |
| }; |
| }/*static init*/ |
| const sigN = tgt.memberSignature(name); |
| if(sigN.length<2){ |
| toss("Member",name,"does not have a function pointer signature:",sigN); |
| } |
| const memKey = tgt.memberKey(name); |
| const fProxy = (applyArgcCheck && !wasm.isPtr(func)) |
| /** This middle-man proxy is only for use during development, to |
| confirm that we always pass the proper number of |
| arguments. We know that the C-level code will always use the |
| correct argument count. */ |
| ? callee.argcProxy(tgt, memKey, func, sigN) |
| : func; |
| if(wasm.isPtr(fProxy)){ |
| if(fProxy && !wasm.functionEntry(fProxy)){ |
| toss("Pointer",fProxy,"is not a WASM function table entry."); |
| } |
| tgt[memKey] = fProxy; |
| }else{ |
| const pFunc = wasm.installFunction(fProxy, tgt.memberSignature(name, true)); |
| tgt[memKey] = pFunc; |
| if(!tgt.ondispose || !tgt.ondispose.__removeFuncList){ |
| tgt.addOnDispose('ondispose.__removeFuncList handler', |
| callee.removeFuncList); |
| tgt.ondispose.__removeFuncList = []; |
| } |
| tgt.ondispose.__removeFuncList.push(memKey, pFunc); |
| } |
| return (n,f)=>callee(tgt, n, f, applyArgcCheck); |
| }/*installMethod*/; |
| installMethod.installMethodArgcCheck = false; |
| |
| /** |
| Installs methods into the given StructBinder.StructType-type |
| instance. Each entry in the given methods object must map to a |
| known member of the given StructType, else an exception will be |
| triggered. See installMethod() for more details, including the |
| semantics of the 3rd argument. |
| |
| As an exception to the above, if any two or more methods in the |
| 2nd argument are the exact same function, installMethod() is |
| _not_ called for the 2nd and subsequent instances, and instead |
| those instances get assigned the same method pointer which is |
| created for the first instance. This optimization is primarily to |
| accommodate special handling of sqlite3_module::xConnect and |
| xCreate methods. |
| |
| On success, returns its first argument. Throws on error. |
| */ |
| const installMethods = function( |
| structInstance, methods, applyArgcCheck = installMethod.installMethodArgcCheck |
| ){ |
| const seen = new Map /* map of <Function, memberName> */; |
| for(const k of Object.keys(methods)){ |
| const m = methods[k]; |
| const prior = seen.get(m); |
| if(prior){ |
| const mkey = structInstance.memberKey(k); |
| structInstance[mkey] = structInstance[structInstance.memberKey(prior)]; |
| }else{ |
| installMethod(structInstance, k, m, applyArgcCheck); |
| seen.set(m, k); |
| } |
| } |
| return structInstance; |
| }; |
| |
| /** |
| Equivalent to calling installMethod(this,...arguments) with a |
| first argument of this object. If called with 1 or 2 arguments |
| and the first is an object, it's instead equivalent to calling |
| installMethods(this,...arguments). |
| */ |
| StructBinder.StructType.prototype.installMethod = function callee( |
| name, func, applyArgcCheck = installMethod.installMethodArgcCheck |
| ){ |
| return (arguments.length < 3 && name && 'object'===typeof name) |
| ? installMethods(this, ...arguments) |
| : installMethod(this, ...arguments); |
| }; |
| |
| /** |
| Equivalent to calling installMethods() with a first argument |
| of this object. |
| */ |
| StructBinder.StructType.prototype.installMethods = function( |
| methods, applyArgcCheck = installMethod.installMethodArgcCheck |
| ){ |
| return installMethods(this, methods, applyArgcCheck); |
| }; |
| |
| }); |
