-
Notifications
You must be signed in to change notification settings - Fork 1.4k
Expand file tree
/
Copy pathsqlite3-api-oo1.c-pp.js
More file actions
2429 lines (2198 loc) · 94.1 KB
/
Copy pathsqlite3-api-oo1.c-pp.js
File metadata and controls
2429 lines (2198 loc) · 94.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//#if not omit-oo1
/*
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 contains the so-called OO #1 API wrapper for the sqlite3
WASM build. It requires that sqlite3-api-glue.js has already run
and it installs its deliverable as sqlite3.oo1.
*/
globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
const toss3 = (...args)=>{throw new sqlite3.SQLite3Error(...args)};
const capi = sqlite3.capi, wasm = sqlite3.wasm, util = sqlite3.util;
/* What follows is colloquially known as "OO API #1". It is a
binding of the sqlite3 API which is designed to be run within
the same thread (main or worker) as the one in which the
sqlite3 WASM binding was initialized. This wrapper cannot use
the sqlite3 binding if, e.g., the wrapper is in the main thread
and the sqlite3 API is in a worker. */
const outWrapper = function(f){
return (...args)=>f("sqlite3.oo1:",...args);
};
const debug = sqlite3.__isUnderTest
? outWrapper(console.debug.bind(console))
: outWrapper(sqlite3.config.debug);
const warn = sqlite3.__isUnderTest
? outWrapper(console.warn.bind(console))
: outWrapper(sqlite3.config.warn);
const error = sqlite3.__isUnderTest
? outWrapper(console.error.bind(console))
: outWrapper(sqlite3.config.error);
/**
In order to keep clients from manipulating, perhaps
inadvertently, the underlying pointer values of DB and Stmt
instances, we'll gate access to them via the `pointer` property
accessor and store their real values in this map. Keys = DB/Stmt
objects, values = pointer values. This also unifies how those are
accessed, for potential use downstream via custom
wasm.xWrap() function signatures which know how to extract
it.
*/
const __ptrMap = new WeakMap();
/**
A Set of oo1.DB or oo1.Stmt objects which are proxies for
(sqlite3*) resp. (sqlite3_stmt*) pointers which themselves are
owned elsewhere. Objects in this Set do not own their underlying
handle and that handle must be guaranteed (by the client) to
outlive the proxy. DB.close()/Stmt.finalize() methods will remove
the object from this Set _instead_ of closing/finalizing the
pointer. These proxies are primarily intended as a way to briefly
wrap an (sqlite3[_stmt]*) object as an oo1.DB/Stmt without taking
over ownership, to take advantage of simplifies usage compared to
the C API while not imposing any change of ownership.
See DB.wrapHandle() and Stmt.wrapHandle().
*/
const __doesNotOwnHandle = new Set();
/**
Map of DB instances to objects, each object being a map of Stmt
wasm pointers to Stmt objects.
*/
const __stmtMap = new WeakMap();
/** If object opts has _its own_ property named p then that
property's value is returned, else dflt is returned. */
const getOwnOption = (opts, p, dflt)=>{
const d = Object.getOwnPropertyDescriptor(opts,p);
return d ? d.value : dflt;
};
// Documented in DB.checkRc()
const checkSqlite3Rc = function(dbPtr, sqliteResultCode){
if(sqliteResultCode){
if(dbPtr instanceof DB) dbPtr = dbPtr.pointer;
toss3(
sqliteResultCode,
"sqlite3 result code",sqliteResultCode+":",
(dbPtr
? capi.sqlite3_errmsg(dbPtr)
: capi.sqlite3_errstr(sqliteResultCode))
);
}
return arguments[0];
};
/**
sqlite3_trace_v2() callback which gets installed by the DB ctor
if its open-flags contain "t".
*/
const __dbTraceToConsole =
wasm.installFunction('i(ippp)', function(t,c,p,x){
if(capi.SQLITE_TRACE_STMT===t){
// x == SQL, p == sqlite3_stmt*
console.log("SQL TRACE #"+(++this.counter),
'via sqlite3@'+c+'['+capi.sqlite3_db_filename(c,null)+']',
wasm.cstrToJs(x));
}
}.bind({counter: 0}));
/**
A map of sqlite3_vfs pointers to SQL code or a callback function
to run when the DB constructor opens a database with the given
VFS. In the latter case, the call signature is
(theDbObject,sqlite3Namespace) and the callback is expected to
throw on error.
*/
const __vfsPostOpenCallback = Object.create(null);
//#if enable-see
/**
Converts ArrayBuffer or Uint8Array ba into a string of hex
digits.
*/
const byteArrayToHex = function(ba){
if( ba instanceof ArrayBuffer ){
ba = new Uint8Array(ba);
}
const li = [];
const digits = "0123456789abcdef";
for( const d of ba ){
li.push( digits[(d & 0xf0) >> 4], digits[d & 0x0f] );
}
return li.join('');
};
/**
Internal helper to apply an SEE key to a just-opened
database. Requires that db be-a DB object which has just been
opened, opt be the options object processed by its ctor, and opt
must have either the key, hexkey, or textkey properties, either
as a string, an ArrayBuffer, or a Uint8Array.
This is a no-op in non-SEE builds. It throws on error and returns
without side effects if none of the key/textkey/hexkey options
are set. It throws if more than one is set or if any are set to
values of an invalid type.
Returns true if it applies the key, else an unspecified falsy
value. Note that applying the key does not imply that the key is
correct, only that it was passed on to the db.
*/
const dbCtorApplySEEKey = function(db,opt){
if( !capi.sqlite3_key_v2 ) return;
let keytype;
let key;
const check = (opt.key ? 1 : 0) + (opt.hexkey ? 1 : 0) + (opt.textkey ? 1 : 0);
if( !check ) return;
else if( check>1 ){
toss3(capi.SQLITE_MISUSE,
"Only ONE of (key, hexkey, textkey) may be provided.");
}
if( opt.key ){
/* It is not legal to bind an argument to PRAGMA key=?, so we
convert it to a hexkey... */
keytype = 'key';
key = opt.key;
if('string'===typeof key){
key = new TextEncoder('utf-8').encode(key);
}
if((key instanceof ArrayBuffer) || (key instanceof Uint8Array)){
key = byteArrayToHex(key);
keytype = 'hexkey';
}else{
toss3(capi.SQLITE_MISUSE,
"Invalid value for the 'key' option. Expecting a string,",
"ArrayBuffer, or Uint8Array.");
return;
}
}else if( opt.textkey ){
/* For textkey we need it to be in string form, so convert it to
a string if it's a byte array... */
keytype = 'textkey';
key = opt.textkey;
if(key instanceof ArrayBuffer){
key = new Uint8Array(key);
}
if(key instanceof Uint8Array){
key = new TextDecoder('utf-8').decode(key);
}else if('string'!==typeof key){
toss3(capi.SQLITE_MISUSE,
"Invalid value for the 'textkey' option. Expecting a string,",
"ArrayBuffer, or Uint8Array.");
}
}else if( opt.hexkey ){
keytype = 'hexkey';
key = opt.hexkey;
if((key instanceof ArrayBuffer) || (key instanceof Uint8Array)){
key = byteArrayToHex(key);
}else if('string'!==typeof key){
toss3(capi.SQLITE_MISUSE,
"Invalid value for the 'hexkey' option. Expecting a string,",
"ArrayBuffer, or Uint8Array.");
}
/* else assume it's valid hex codes */
}else{
return;
}
let stmt;
try{
stmt = db.prepare("PRAGMA "+keytype+"="+util.sqlite3__wasm_qfmt_token(key, 1));
stmt.step();
return true;
}finally{
if(stmt) stmt.finalize();
}
};
//#/if enable-see
/**
A proxy for DB class constructors. It must be called with the
being-construct DB object as its "this". See the DB constructor
for the argument docs. This is split into a separate function
in order to enable simple creation of special-case DB constructors,
e.g. JsStorageDb and OpfsDb.
Expects to be passed a configuration object with the following
properties:
- `.filename`: the db filename. It may be a special name like ":memory:"
or "". It may also be a URI-style name.
- `.flags`: as documented in the DB constructor.
- `.vfs`: as documented in the DB constructor.
It also accepts those as the first 3 arguments.
In non-default builds it may accept additional configuration
options.
*/
const dbCtorHelper = function ctor(...args){
const opt = ctor.normalizeArgs(...args);
//sqlite3.config.debug("DB ctor",opt);
let pDb;
if( (pDb = opt['sqlite3*']) ){
/* This property ^^^^^ is very specifically NOT DOCUMENTED and
NOT part of the public API. This is a back door for functions
like DB.wrapDbHandle(). */
//sqlite3.config.debug("creating proxy db from",opt);
if( !opt['sqlite3*:takeOwnership'] ){
/* This is object does not own its handle. */
__doesNotOwnHandle.add(this);
}
this.filename = capi.sqlite3_db_filename(pDb,'main');
}else{
let fn = opt.filename, vfsName = opt.vfs, flagsStr = opt.flags;
if( ('string'!==typeof fn && !wasm.isPtr(fn))
|| 'string'!==typeof flagsStr
|| (vfsName && ('string'!==typeof vfsName && !wasm.isPtr(vfsName))) ){
sqlite3.config.error("Invalid DB ctor args",opt,arguments);
toss3("Invalid arguments for DB constructor:", arguments, "opts:", opt);
}
let oflags = 0;
if( flagsStr.indexOf('c')>=0 ){
oflags |= capi.SQLITE_OPEN_CREATE | capi.SQLITE_OPEN_READWRITE;
}
if( flagsStr.indexOf('w')>=0 ) oflags |= capi.SQLITE_OPEN_READWRITE;
if( 0===oflags ) oflags |= capi.SQLITE_OPEN_READONLY;
oflags |= capi.SQLITE_OPEN_EXRESCODE;
const stack = wasm.pstack.pointer;
try {
const pPtr = wasm.pstack.allocPtr() /* output (sqlite3**) arg */;
let rc = capi.sqlite3_open_v2(fn, pPtr, oflags, vfsName || wasm.ptr.null);
pDb = wasm.peekPtr(pPtr);
checkSqlite3Rc(pDb, rc);
capi.sqlite3_extended_result_codes(pDb, 1);
if(flagsStr.indexOf('t')>=0){
capi.sqlite3_trace_v2(pDb, capi.SQLITE_TRACE_STMT,
__dbTraceToConsole, pDb);
}
}catch( e ){
if( pDb ) capi.sqlite3_close_v2(pDb);
throw e;
}finally{
wasm.pstack.restore(stack);
}
this.filename =
/* A poor design choice we have to keep: this.filename may be
in the form "file:....?....". It really should have been
sqlite3_db_filename(pDb) but that discrepancy went too long
unnoticed to be able to change without risk of
breakage. DB.dbFilename() can be used to fetch _just_ the
name part.
*/ wasm.isPtr(fn) ? wasm.cstrToJs(fn) : fn;
}
__ptrMap.set(this, pDb);
__stmtMap.set(this, Object.create(null));
if( !opt['sqlite3*'] ){
try{
//#if enable-see
dbCtorApplySEEKey(this,opt);
//#/if
// Check for per-VFS post-open SQL/callback...
const pVfs = capi.sqlite3_js_db_vfs(pDb)
|| toss3("Internal error: cannot get VFS for new db handle.");
const postInitSql = __vfsPostOpenCallback[pVfs];
if(postInitSql){
/**
Reminder: if this db is encrypted and the client did _not_ pass
in the key, any init code will fail, causing the ctor to throw.
We don't actually know whether the db is encrypted, so we cannot
sensibly apply any heuristics which skip the init code only for
encrypted databases for which no key has yet been supplied.
*/
if(postInitSql instanceof Function){
postInitSql(this, sqlite3);
}else{
checkSqlite3Rc(
pDb, capi.sqlite3_exec(pDb, postInitSql, 0, 0, 0)
);
}
}
}catch(e){
this.close();
throw e;
}
}
};
/**
Sets a callback which should be called after a db is opened with
the given sqlite3_vfs pointer. The 2nd argument must be a
function, which gets called with
(theOo1DbObject,sqlite3Namespace) at the end of the DB()
constructor. The function must throw on error, in which case the
db is closed and the exception is propagated. This function is
intended only for use by DB subclasses or sqlite3_vfs
implementations.
Prior to 2024-07-22, it was legal to pass SQL code as the second
argument, but that can interfere with a client's ability to run
pragmas which must be run before anything else, namely (pragma
locking_mode=exclusive) for use with WAL mode. That capability
had only ever been used as an internal detail of the two OPFS
VFSes, and they no longer use it that way.
*/
dbCtorHelper.setVfsPostOpenCallback = function(pVfs, callback){
if( !(callback instanceof Function)){
toss3("dbCtorHelper.setVfsPostOpenCallback() should not be used with "+
"a non-function argument.",arguments);
}
__vfsPostOpenCallback[pVfs] = callback;
};
/**
A helper for DB constructors. It accepts either a single
config-style object or up to 3 arguments (filename, dbOpenFlags,
dbVfsName). It returns a new object containing:
{ filename: ..., flags: ..., vfs: ... }
If passed an object, any additional properties it has are copied
as-is into the new object.
*/
dbCtorHelper.normalizeArgs = function(filename=':memory:',flags = 'c',vfs = null){
const arg = {};
if(1===arguments.length && arguments[0] && 'object'===typeof arguments[0]){
Object.assign(arg, arguments[0]);
if(undefined===arg.flags) arg.flags = 'c';
if(undefined===arg.vfs) arg.vfs = null;
if(undefined===arg.filename) arg.filename = ':memory:';
}else{
arg.filename = filename;
arg.flags = flags;
arg.vfs = vfs;
}
return arg;
};
/**
The DB class provides a high-level OO wrapper around an sqlite3
db handle.
The given db filename must be resolvable using whatever
filesystem layer (virtual or otherwise) is set up for the default
sqlite3 VFS or a VFS which can resolve it must be specified.
The special sqlite3 db names ":memory:" and "" (temporary db)
have their normal special meanings here and need not resolve to
real filenames, but "" uses an on-storage temporary database and
requires that the VFS support that.
The second argument specifies the open/create mode for the
database. It must be string containing a sequence of letters (in
any order, but case sensitive) specifying the mode:
- "c": create if it does not exist, else fail if it does not
exist. Implies the "w" flag.
- "w": write. Implies "r": a db cannot be write-only.
- "r": read-only if neither "w" nor "c" are provided, else it
is ignored.
- "t": enable tracing of SQL executed on this database handle,
sending it to `console.log()`. To disable it later, call
`sqlite3.capi.sqlite3_trace_v2(thisDb.pointer, 0, 0, 0)`.
If "w" is not provided, the db is implicitly read-only, noting
that "rc" is meaningless
Any other letters are currently ignored. The default is
"c". These modes are ignored for the special ":memory:" and ""
names and _may_ be ignored altogether for certain VFSes.
The final argument is analogous to the final argument of
sqlite3_open_v2(): the name of an sqlite3 VFS. Pass a falsy value,
or none at all, to use the default. If passed a value, it must
be the string name of a VFS.
The constructor optionally (and preferably) takes its arguments
in the form of a single configuration object with the following
properties:
- `filename`: database file name
- `flags`: open-mode flags
- `vfs`: the VFS fname
//#if enable-see
SEE-capable builds optionally support ONE of the following
additional options:
- `key`, `hexkey`, or `textkey`: encryption key as a string,
ArrayBuffer, or Uint8Array. These flags function as documented
for the SEE pragmas of the same names. Using a byte array for
`hexkey` is equivalent to the same series of hex codes in
string form, so `'666f6f'` is equivalent to
`Uint8Array([0x66,0x6f,0x6f])`. A `textkey` byte array is
assumed to be UTF-8. A `key` string is transformed into a UTF-8
byte array, and a `key` byte array is transformed into a
`hexkey` with the same bytes.
In non-SEE builds, these options are ignored. In SEE builds,
`PRAGMA key/textkey/hexkey=X` is executed immediately after
opening the db. If more than one of the options is provided,
or any option has an invalid argument type, an exception is
thrown.
Note that some DB subclasses may run post-initialization SQL
code, e.g. to set a busy-handler timeout or tweak the page cache
size. Such code is run _after_ the SEE key is applied. If no key
is supplied and the database is encrypted, execution of the
post-initialization SQL will fail, causing the constructor to
throw.
//#/if enable-see
The `filename` and `vfs` arguments may be either JS strings or
C-strings allocated via WASM. `flags` is required to be a JS
string (because it's specific to this API, which is specific
to JS).
For purposes of passing a DB instance to C-style sqlite3
functions, the DB object's read-only `pointer` property holds its
`sqlite3*` pointer value. That property can also be used to check
whether this DB instance is still open: it will evaluate to
`undefined` after the DB object's close() method is called.
In the main window thread, the filenames `":localStorage:"` and
`":sessionStorage:"` are special: they cause the db to use either
localStorage or sessionStorage for storing the database using
the kvvfs. If one of these names are used, they trump
any vfs name set in the arguments.
*/
const DB = function(...args){
dbCtorHelper.apply(this, args);
};
DB.dbCtorHelper = dbCtorHelper;
/**
Internal-use enum for mapping JS types to DB-bindable types.
These do not (and need not) line up with the SQLITE_type
values. All values in this enum must be truthy and (mostly)
distinct but they need not be numbers.
*/
const BindTypes = {
null: 1,
number: 2,
string: 3,
boolean: 4,
blob: 5
};
if(wasm.bigIntEnabled){
BindTypes.bigint = BindTypes.number;
}
/**
This class wraps sqlite3_stmt. Calling this constructor
directly will trigger an exception. Use DB.prepare() to create
new instances.
For purposes of passing a Stmt instance to C-style sqlite3
functions, its read-only `pointer` property holds its `sqlite3_stmt*`
pointer value.
Other non-function properties include:
- `db`: the DB object which created the statement.
- `columnCount`: the number of result columns in the query, or 0
for queries which cannot return results. This property is a
read-only proxy for sqlite3_column_count() and its use in loops
should be avoided because of the call overhead associated with
that. The `columnCount` is not cached when the Stmt is created
because a schema change made between this statement's preparation
and when it is stepped may invalidate it.
- `parameterCount`: the number of bindable parameters in the
query. Like `columnCount`, this property is ready-only and is a
proxy for a C API call.
As a general rule, most methods of this class will throw if
called on an instance which has been finalized. For brevity's
sake, the method docs do not all repeat this warning.
*/
const Stmt = function(/*oo1db, stmtPtr, BindTypes [,takeOwnership=true] */){
if(BindTypes!==arguments[2]){
toss3(capi.SQLITE_MISUSE, "Do not call the Stmt constructor directly. Use DB.prepare().");
}
this.db = arguments[0];
__ptrMap.set(this, arguments[1]);
if( arguments.length>3 && !arguments[3] ){
__doesNotOwnHandle.add(this);
}
};
/** Throws if the given DB has been closed, else it is returned. */
const affirmDbOpen = function(db){
if(!db.pointer) toss3("DB has been closed.");
return db;
};
/** Throws if ndx is not an integer or if it is out of range
for stmt.columnCount, else returns stmt.
Reminder: this will also fail after the statement is finalized
but the resulting error will be about an out-of-bounds column
index rather than a statement-is-finalized error.
*/
const affirmColIndex = function(stmt,ndx){
if((ndx !== (ndx|0)) || ndx<0 || ndx>=stmt.columnCount){
toss3("Column index",ndx,"is out of range.");
}
return stmt;
};
/**
Expects to be passed the `arguments` object from DB.exec(). Does
the argument processing/validation, throws on error, and returns
a new object on success:
{ sql: the SQL, opt: optionsObj, cbArg: function}
The opt object is a normalized copy of any passed to this
function. The sql will be converted to a string if it is provided
in one of the supported non-string formats.
cbArg is only set if the opt.callback or opt.resultRows are set,
in which case it's a function which expects to be passed the
current Stmt and returns the callback argument of the type
indicated by the input arguments.
*/
const parseExecArgs = function(db, args){
const out = Object.create(null);
out.opt = Object.create(null);
switch(args.length){
case 1:
if('string'===typeof args[0] || util.isSQLableTypedArray(args[0])){
out.sql = args[0];
}else if(Array.isArray(args[0])){
out.sql = args[0];
}else if(args[0] && 'object'===typeof args[0]){
out.opt = args[0];
out.sql = out.opt.sql;
}
break;
case 2:
out.sql = args[0];
out.opt = args[1];
break;
default: toss3("Invalid argument count for exec().");
};
out.sql = util.flexibleString(out.sql);
if('string'!==typeof out.sql){
toss3("Missing SQL argument or unsupported SQL value type.");
}
const opt = out.opt;
switch(opt.returnValue){
case 'resultRows':
if(!opt.resultRows) opt.resultRows = [];
out.returnVal = ()=>opt.resultRows;
break;
case 'saveSql':
if(!opt.saveSql) opt.saveSql = [];
out.returnVal = ()=>opt.saveSql;
break;
case undefined:
case 'this':
out.returnVal = ()=>db;
break;
default:
toss3("Invalid returnValue value:",opt.returnValue);
}
if(!opt.callback && !opt.returnValue && undefined!==opt.rowMode){
if(!opt.resultRows) opt.resultRows = [];
out.returnVal = ()=>opt.resultRows;
}
if(opt.callback || opt.resultRows){
switch((undefined===opt.rowMode) ? 'array' : opt.rowMode) {
case 'object':
out.cbArg = (stmt,cache)=>{
if( !cache.columnNames ) cache.columnNames = stmt.getColumnNames([]);
/* https://sqlite.org/forum/forumpost/3632183d2470617d:
conversion of rows to objects (key/val pairs) is
somewhat expensive for large data sets because of the
native-to-JS conversion of the column names. If we
instead cache the names and build objects from that
list of strings, it can run twice as fast. The
difference is not noticeable for small data sets but
becomes human-perceivable when enough rows are
involved. */
const row = stmt.get([]);
const rv = Object.create(null);
for( const i in cache.columnNames ) rv[cache.columnNames[i]] = row[i];
return rv;
};
break;
case 'array': out.cbArg = (stmt)=>stmt.get([]); break;
case 'stmt':
if(Array.isArray(opt.resultRows)){
toss3("exec(): invalid rowMode for a resultRows array: must",
"be one of 'array', 'object',",
"a result column number, or column name reference.");
}
out.cbArg = (stmt)=>stmt;
break;
default:
if(util.isInt32(opt.rowMode)){
out.cbArg = (stmt)=>stmt.get(opt.rowMode);
break;
}else if('string'===typeof opt.rowMode
&& opt.rowMode.length>1
&& '$'===opt.rowMode[0]){
/* "$X": fetch column named "X" (case-sensitive!). Prior
to 2022-12-14 ":X" and "@X" were also permitted, but
having so many options is unnecessary and likely to
cause confusion. */
const $colName = opt.rowMode.substr(1);
out.cbArg = (stmt)=>{
const rc = stmt.get(Object.create(null))[$colName];
return (undefined===rc)
? toss3(capi.SQLITE_NOTFOUND,
"exec(): unknown result column:",$colName)
: rc;
};
break;
}
toss3("Invalid rowMode:",opt.rowMode);
}
}
return out;
};
/**
Internal impl of the DB.selectValue(), selectArray(), and
selectObject() methods.
*/
const __selectFirstRow = (db, sql, bind, ...getArgs)=>{
const stmt = db.prepare(sql);
try {
const rc = stmt.bind(bind).step() ? stmt.get(...getArgs) : undefined;
stmt.reset(/*for INSERT...RETURNING locking case*/);
return rc;
}finally{
stmt.finalize();
}
};
/**
Internal impl of the DB.selectArrays() and selectObjects()
methods.
*/
const __selectAll =
(db, sql, bind, rowMode)=>db.exec({
sql, bind, rowMode, returnValue: 'resultRows'
});
/**
Expects to be given a DB instance or an `sqlite3*` pointer (may
be null) and an sqlite3 API result code. If the result code is
not falsy, this function throws an SQLite3Error with an error
message from sqlite3_errmsg(), using db (or, if db is-a DB,
db.pointer) as the db handle, or sqlite3_errstr() if db is
falsy. Note that if it's passed a non-error code like SQLITE_ROW
or SQLITE_DONE, it will still throw but the error string might be
"Not an error." The various non-0 non-error codes need to be
checked for in client code where they are expected.
The thrown exception's `resultCode` property will be the value of
the second argument to this function.
If it does not throw, it returns its first argument.
*/
DB.checkRc = (db,resultCode)=>checkSqlite3Rc(db,resultCode);
DB.prototype = {
/** Returns true if this db handle is open, else false. */
isOpen: function(){
return !!this.pointer;
},
/** Throws if this given DB has been closed, else returns `this`. */
affirmOpen: function(){
return affirmDbOpen(this);
},
/**
Finalizes all open statements and closes this database
connection (with one exception noted below). This is a no-op if
the db has already been closed. After calling close(),
`this.pointer` will resolve to `undefined`, and that can be
used to check whether the db instance is still opened.
If this.onclose.before is a function then it is called before
any close-related cleanup.
If this.onclose.after is a function then it is called after the
db is closed but before auxiliary state like this.filename is
cleared.
Both onclose handlers are passed this object, with the onclose
object as their "this," noting that the db will have been
closed when onclose.after is called. If this db is not opened
when close() is called, neither of the handlers are called. Any
exceptions the handlers throw are ignored because "destructors
must not throw".
Garbage collection of a db handle, if it happens at all, will
never trigger close(), so onclose handlers are not a reliable
way to implement close-time cleanup or maintenance of a db.
If this instance was created using DB.wrapHandle() and does not
own this.pointer then it does not close the db handle but it
does perform all other work, such as calling onclose callbacks
and disassociating this object from this.pointer.
*/
close: function(){
const pDb = this.pointer;
if(pDb){
if(this.onclose && (this.onclose.before instanceof Function)){
try{this.onclose.before(this)}
catch(e){/*ignore*/}
}
Object.keys(__stmtMap.get(this)).forEach((k,s)=>{
if(s && s.pointer){
try{s.finalize()}
catch(e){/*ignore*/}
}
});
__ptrMap.delete(this);
__stmtMap.delete(this);
if( !__doesNotOwnHandle.delete(this) ){
capi.sqlite3_close_v2(pDb);
}
if(this.onclose && (this.onclose.after instanceof Function)){
try{this.onclose.after(this)}
catch(e){/*ignore*/}
}
delete this.filename;
}
},
/**
Returns the number of changes, as per sqlite3_changes()
(if the first argument is false) or sqlite3_total_changes()
(if it's true). If the 2nd argument is true, it uses
sqlite3_changes64() or sqlite3_total_changes64(), which
will trigger an exception if this build does not have
BigInt support enabled.
*/
changes: function(total=false,sixtyFour=false){
const p = affirmDbOpen(this).pointer;
if(total){
return sixtyFour
? capi.sqlite3_total_changes64(p)
: capi.sqlite3_total_changes(p);
}else{
return sixtyFour
? capi.sqlite3_changes64(p)
: capi.sqlite3_changes(p);
}
},
/**
Similar to the this.filename but returns the
sqlite3_db_filename() value for the given database name,
defaulting to "main". The argument may be either a JS string
or a pointer to a WASM-allocated C-string.
this.filename may be in the form of a URI-style string, whereas
the returned string contains only the filename part.
*/
dbFilename: function(dbName='main'){
return capi.sqlite3_db_filename(affirmDbOpen(this).pointer, dbName);
},
/**
Returns the name of the given 0-based db number, as documented
for sqlite3_db_name().
*/
dbName: function(dbNumber=0){
return capi.sqlite3_db_name(affirmDbOpen(this).pointer, dbNumber);
},
/**
Returns the name of the sqlite3_vfs used by the given database
of this connection (defaulting to 'main'). The argument may be
either a JS string or a WASM C-string. Returns undefined if the
given db name is invalid. Throws if this object has been
close()d.
*/
dbVfsName: function(dbName=0){
let rc;
const pVfs = capi.sqlite3_js_db_vfs(
affirmDbOpen(this).pointer, dbName
);
if(pVfs){
const v = new capi.sqlite3_vfs(pVfs);
try{ rc = wasm.cstrToJs(v.$zName) }
finally { v.dispose() }
}
return rc;
},
/**
Compiles the given SQL and returns a prepared Stmt. This is
the only way to create new Stmt objects. Throws on error.
The given SQL must be a string, a Uint8Array holding SQL, a
WASM pointer to memory holding the NUL-terminated SQL string,
or an array of strings. In the latter case, the array is
concatenated together, with no separators, to form the SQL
string (arrays are often a convenient way to formulate long
statements). If the SQL contains no statements, an
SQLite3Error is thrown.
Design note: the C API permits empty SQL, reporting it as a 0
result code and a NULL stmt pointer. Supporting that case here
would cause extra work for all clients: any use of the Stmt API
on such a statement will necessarily throw, so clients would be
required to check `stmt.pointer` after calling `prepare()` in
order to determine whether the Stmt instance is empty or not.
Long-time practice (with other sqlite3 script bindings)
suggests that the empty-prepare case is sufficiently rare that
supporting it here would simply hurt overall usability.
*/
prepare: function(sql){
affirmDbOpen(this);
const stack = wasm.pstack.pointer;
let ppStmt, pStmt;
try{
ppStmt = wasm.pstack.alloc(8)/* output (sqlite3_stmt**) arg */;
DB.checkRc(this, capi.sqlite3_prepare_v2(this.pointer, sql, -1, ppStmt, null));
pStmt = wasm.peekPtr(ppStmt);
}
finally {
wasm.pstack.restore(stack);
}
if(!pStmt) toss3("Cannot prepare empty SQL.");
const stmt = new Stmt(this, pStmt, BindTypes);
__stmtMap.get(this)[pStmt] = stmt;
return stmt;
},
/**
Executes one or more SQL statements in the form of a single
string. Its arguments must be either (sql,optionsObject) or
(optionsObject). In the latter case, optionsObject.sql must
contain the SQL to execute. By default it returns this object
but that can be changed via the `returnValue` option as
described below. Throws on error.
If no SQL is provided, or a non-string is provided, an
exception is triggered. Empty SQL, on the other hand, is
simply a no-op.
The optional options object may contain any of the following
properties:
- `sql` = the SQL to run (unless it's provided as the first
argument). This must be of type string, Uint8Array, or an array
of strings. In the latter case they're concatenated together
as-is, _with no separator_ between elements, before evaluation.
The array form is often simpler for long hand-written queries.
- `bind` = a single value valid as an argument for
Stmt.bind(). This is _only_ applied to the _first_ non-empty
statement in the SQL which has any bindable parameters. (Empty
statements are skipped entirely.)
- `saveSql` = an optional array. If set, the SQL of each
executed statement is appended to this array before the
statement is executed (but after it is prepared - we don't have
the string until after that). Empty SQL statements are elided
but can have odd effects in the output. e.g. SQL of: `"select
1; -- empty\n; select 2"` will result in an array containing
`["select 1;", "--empty \n; select 2"]`. That's simply how
sqlite3 records the SQL for the 2nd statement.
==================================================================
The following options apply _only_ to the _first_ statement
which has a non-zero result column count, regardless of whether
the statement actually produces any result rows.
==================================================================
- `columnNames`: if this is an array, the column names of the
result set are stored in this array before the callback (if
any) is triggered (regardless of whether the query produces any
result rows). If no statement has result columns, this value is
unchanged. Achtung: an SQL result may have multiple columns
with identical names.
- `callback` = a function which gets called for each row of the
result set, but only if that statement has any result rows. The
callback's "this" is the options object, noting that this
function synthesizes one if the caller does not pass one to
exec(). The first argument passed to the callback is described
below. The second argument is always the current Stmt object,
as it's needed if the caller wants to fetch the column names or
some such (noting that they could also be fetched via
`this.columnNames`, if the client provides the `columnNames`
option). If the callback returns a literal `false` (as opposed
to any other falsy value, e.g. an implicit `undefined` return),
any ongoing statement-`step()` iteration stops without an
error. The return value of the callback is otherwise ignored.
ACHTUNG: The callback MUST NOT modify the Stmt object. Calling
any of the Stmt.get() variants, Stmt.getColumnName(), or
similar, is legal, but calling step() or finalize() is
not. Member methods which are illegal in this context will
trigger an exception, but clients must also refrain from using
any lower-level (C-style) APIs which might modify the
statement.
The first argument passed to the callback defaults to an array of
values from the current result row but may be changed with ...
- `rowMode` = specifies the type of he callback's first argument.
It may be any of...
A) A string describing what type of argument should be passed
as the first argument to the callback:
A.1) `'array'` (the default) causes the results of
`stmt.get([])` to be passed to the `callback` and/or appended
to `resultRows`.
A.2) `'object'` causes the results of
`stmt.get(Object.create(null))` to be passed to the
`callback` and/or appended to `resultRows`. Achtung: an SQL
result may have multiple columns with identical names. In
that case, the right-most column will be the one set in this
object!
A.3) `'stmt'` causes the current Stmt to be passed to the
callback, but this mode will trigger an exception if
`resultRows` is an array because appending the transient
statement to the array would be downright unhelpful. This
option is a legacy feature, retained for backwards
compatibility. The statement object is passed as the second
argument to the callback, as described above.
B) An integer, indicating a zero-based column in the result
row. Only that one single value, in JS form, will be passed on.
C) A string with a minimum length of 2 and leading character of
'$' will fetch the row as an object, extract that one field,
and pass that field's value to the callback. These keys are
case-sensitive so must match the case used in the
SQL. e.g. `"select a A from t"` with a `rowMode` of `'$A'`
would work but `'$a'` would not. A reference to a column not in
the result set will trigger an exception on the first row (as
the check is not performed until rows are fetched). Note that
`$` is a legal identifier character in JS so need not be
quoted.
Any other `rowMode` value triggers an exception.
- `resultRows`: if this is an array, it functions similarly to
the `callback` option: each row of the result set (if any),
with the exception that the `rowMode` 'stmt' is not legal. It
is legal to use both `resultRows` and `callback`, but
`resultRows` is likely much simpler to use for small data sets
and can be used over a WebWorker-style message interface.
exec() throws if `resultRows` is set and `rowMode` is 'stmt'.
- `returnValue`: is a string specifying what this function
should return: