File size: 9,593 Bytes
661c4fc |
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 |
/*
2022-09-19
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.
***********************************************************************
A basic demonstration of the SQLite3 "OO#1" API.
*/
'use strict';
(function(){
/**
Set up our output channel differently depending
on whether we are running in a worker thread or
the main (UI) thread.
*/
let logHtml;
if(globalThis.window === globalThis /* UI thread */){
console.log("Running demo from main UI thread.");
logHtml = function(cssClass,...args){
const ln = document.createElement('div');
if(cssClass) ln.classList.add(cssClass);
ln.append(document.createTextNode(args.join(' ')));
document.body.append(ln);
};
}else{ /* Worker thread */
console.log("Running demo from Worker thread.");
logHtml = function(cssClass,...args){
postMessage({
type:'log',
payload:{cssClass, args}
});
};
}
const log = (...args)=>logHtml('',...args);
const warn = (...args)=>logHtml('warning',...args);
const error = (...args)=>logHtml('error',...args);
const demo1 = function(sqlite3){
const capi = sqlite3.capi/*C-style API*/,
oo = sqlite3.oo1/*high-level OO API*/;
log("sqlite3 version",capi.sqlite3_libversion(), capi.sqlite3_sourceid());
const db = new oo.DB("/mydb.sqlite3",'ct');
log("transient db =",db.filename);
/**
Never(!) rely on garbage collection to clean up DBs and
(especially) prepared statements. Always wrap their lifetimes
in a try/finally construct, as demonstrated below. By and
large, client code can entirely avoid lifetime-related
complications of prepared statement objects by using the
DB.exec() method for SQL execution.
*/
try {
log("Create a table...");
db.exec("CREATE TABLE IF NOT EXISTS t(a,b)");
//Equivalent:
db.exec({
sql:"CREATE TABLE IF NOT EXISTS t(a,b)"
// ... numerous other options ...
});
// SQL can be either a string or a byte array
// or an array of strings which get concatenated
// together as-is (so be sure to end each statement
// with a semicolon).
log("Insert some data using exec()...");
let i;
for( i = 20; i <= 25; ++i ){
db.exec({
sql: "insert into t(a,b) values (?,?)",
// bind by parameter index...
bind: [i, i*2]
});
db.exec({
sql: "insert into t(a,b) values ($a,$b)",
// bind by parameter name...
bind: {$a: i * 10, $b: i * 20}
});
}
log("Insert using a prepared statement...");
let q = db.prepare([
// SQL may be a string or array of strings
// (concatenated w/o separators).
"insert into t(a,b) ",
"values(?,?)"
]);
try {
for( i = 100; i < 103; ++i ){
q.bind( [i, i*2] ).step();
q.reset();
}
// Equivalent...
for( i = 103; i <= 105; ++i ){
q.bind(1, i).bind(2, i*2).stepReset();
}
}finally{
q.finalize();
}
log("Query data with exec() using rowMode 'array'...");
db.exec({
sql: "select a from t order by a limit 3",
rowMode: 'array', // 'array' (default), 'object', or 'stmt'
callback: function(row){
log("row ",++this.counter,"=",row);
}.bind({counter: 0})
});
log("Query data with exec() using rowMode 'object'...");
db.exec({
sql: "select a as aa, b as bb from t order by aa limit 3",
rowMode: 'object',
callback: function(row){
log("row ",++this.counter,"=",JSON.stringify(row));
}.bind({counter: 0})
});
log("Query data with exec() using rowMode 'stmt'...");
db.exec({
sql: "select a from t order by a limit 3",
rowMode: 'stmt',
callback: function(row){
log("row ",++this.counter,"get(0) =",row.get(0));
}.bind({counter: 0})
});
log("Query data with exec() using rowMode INTEGER (result column index)...");
db.exec({
sql: "select a, b from t order by a limit 3",
rowMode: 1, // === result column 1
callback: function(row){
log("row ",++this.counter,"b =",row);
}.bind({counter: 0})
});
log("Query data with exec() using rowMode $COLNAME (result column name)...");
db.exec({
sql: "select a a, b from t order by a limit 3",
rowMode: '$a',
callback: function(value){
log("row ",++this.counter,"a =",value);
}.bind({counter: 0})
});
log("Query data with exec() without a callback...");
let resultRows = [];
db.exec({
sql: "select a, b from t order by a limit 3",
rowMode: 'object',
resultRows: resultRows
});
log("Result rows:",JSON.stringify(resultRows,undefined,2));
log("Create a scalar UDF...");
db.createFunction({
name: 'twice',
xFunc: function(pCx, arg){ // note the call arg count
return arg + arg;
}
});
log("Run scalar UDF and collect result column names...");
let columnNames = [];
db.exec({
sql: "select a, twice(a), twice(''||a) from t order by a desc limit 3",
columnNames: columnNames,
rowMode: 'stmt',
callback: function(row){
log("a =",row.get(0), "twice(a) =", row.get(1),
"twice(''||a) =",row.get(2));
}
});
log("Result column names:",columnNames);
try{
log("The following use of the twice() UDF will",
"fail because of incorrect arg count...");
db.exec("select twice(1,2,3)");
}catch(e){
warn("Got expected exception:",e.message);
}
try {
db.transaction( function(D) {
D.exec("delete from t");
log("In transaction: count(*) from t =",db.selectValue("select count(*) from t"));
throw new sqlite3.SQLite3Error("Demonstrating transaction() rollback");
});
}catch(e){
if(e instanceof sqlite3.SQLite3Error){
log("Got expected exception from db.transaction():",e.message);
log("count(*) from t =",db.selectValue("select count(*) from t"));
}else{
throw e;
}
}
try {
db.savepoint( function(D) {
D.exec("delete from t");
log("In savepoint: count(*) from t =",db.selectValue("select count(*) from t"));
D.savepoint(function(DD){
const rows = [];
DD.exec({
sql: ["insert into t(a,b) values(99,100);",
"select count(*) from t"],
rowMode: 0,
resultRows: rows
});
log("In nested savepoint. Row count =",rows[0]);
throw new sqlite3.SQLite3Error("Demonstrating nested savepoint() rollback");
})
});
}catch(e){
if(e instanceof sqlite3.SQLite3Error){
log("Got expected exception from nested db.savepoint():",e.message);
log("count(*) from t =",db.selectValue("select count(*) from t"));
}else{
throw e;
}
}
}finally{
db.close();
}
log("That's all, folks!");
/**
Some of the features of the OO API not demonstrated above...
- get change count (total or statement-local, 32- or 64-bit)
- get a DB's file name
Misc. Stmt features:
- Various forms of bind()
- clearBindings()
- reset()
- Various forms of step()
- Variants of get() for explicit type treatment/conversion,
e.g. getInt(), getFloat(), getBlob(), getJSON()
- getColumnName(ndx), getColumnNames()
- getParamIndex(name)
*/
}/*demo1()*/;
log("Loading and initializing sqlite3 module...");
if(globalThis.window!==globalThis) /*worker thread*/{
/*
If sqlite3.js is in a directory other than this script, in order
to get sqlite3.js to resolve sqlite3.wasm properly, we have to
explicitly tell it where sqlite3.js is being loaded from. We do
that by passing the `sqlite3.dir=theDirName` URL argument to
_this_ script. That URL argument will be seen by the JS/WASM
loader and it will adjust the sqlite3.wasm path accordingly. If
sqlite3.js/.wasm are in the same directory as this script then
that's not needed.
URL arguments passed as part of the filename via importScripts()
are simply lost, and such scripts see the globalThis.location of
_this_ script.
*/
let sqlite3Js = 'sqlite3.js';
const urlParams = new URL(globalThis.location.href).searchParams;
if(urlParams.has('sqlite3.dir')){
sqlite3Js = urlParams.get('sqlite3.dir') + '/' + sqlite3Js;
}
importScripts(sqlite3Js);
}
globalThis.sqlite3InitModule({
/* We can redirect any stdout/stderr from the module like so, but
note that doing so makes use of Emscripten-isms, not
well-defined sqlite APIs. */
print: log,
printErr: error
}).then(function(sqlite3){
//console.log('sqlite3 =',sqlite3);
log("Done initializing. Running demo...");
try {
demo1(sqlite3);
}catch(e){
error("Exception:",e.message);
}
});
})();
|