Merge from trunk prepratory to branch end.
FossilOrigin-Name: 1d01f8483af7b6a4e93a49fd8bbb6a2b9300e969b574efeb96d56081a33055c4
This commit is contained in:
+2
-1
@@ -91,7 +91,8 @@ static const ubyte b64DigitValues[128] = {
|
||||
static const char b64Numerals[64+1]
|
||||
= "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
|
||||
#define BX_DV_PROTO(c) ((((ubyte)(c))<0x80)? b64DigitValues[c] : 0x80)
|
||||
#define BX_DV_PROTO(c) \
|
||||
((((ubyte)(c))<0x80)? (ubyte)(b64DigitValues[(ubyte)(c)]) : 0x80)
|
||||
#define IS_BX_DIGIT(bdp) (((ubyte)(bdp))<0x80)
|
||||
#define IS_BX_WS(bdp) ((bdp)==WS)
|
||||
#define IS_BX_PAD(bdp) ((bdp)==PC)
|
||||
|
||||
@@ -69,7 +69,6 @@ int sqlite3_basexx_init(sqlite3 *db, char **pzErr,
|
||||
init_api_ptr(pApi);
|
||||
int rc1 = BASE64_INIT(db);
|
||||
int rc2 = BASE85_INIT(db);
|
||||
int rc = SQLITE_OK;
|
||||
|
||||
if( rc1==SQLITE_OK && rc2==SQLITE_OK ){
|
||||
BASE64_EXPOSE(db, pzErr);
|
||||
|
||||
@@ -66,6 +66,8 @@ _sqlite3_result_int
|
||||
_sqlite3_result_int64
|
||||
_sqlite3_result_null
|
||||
_sqlite3_result_text
|
||||
_sqlite3_result_zeroblob
|
||||
_sqlite3_result_zeroblob64
|
||||
_sqlite3_serialize
|
||||
_sqlite3_shutdown
|
||||
_sqlite3_sourceid
|
||||
|
||||
@@ -748,18 +748,20 @@ self.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
|
||||
returned pointer must eventually be passed to
|
||||
wasm.dealloc() to clean it up.
|
||||
|
||||
The argument may be a Uint8Array, Int8Array, or ArrayBuffer,
|
||||
and it throws if passed any other type.
|
||||
|
||||
As a special case, to avoid further special cases where
|
||||
this is used, if srcTypedArray.byteLength is 0, it
|
||||
allocates a single byte and sets it to the value
|
||||
0. Even in such cases, calls must behave as if the
|
||||
allocated memory has exactly srcTypedArray.byteLength
|
||||
bytes.
|
||||
|
||||
ACHTUNG: this currently only works for Uint8Array and
|
||||
Int8Array types and will throw if srcTypedArray is of
|
||||
any other type.
|
||||
*/
|
||||
wasm.allocFromTypedArray = function(srcTypedArray){
|
||||
if(srcTypedArray instanceof ArrayBuffer){
|
||||
srcTypedArray = new Uint8Array(srcTypedArray);
|
||||
}
|
||||
affirmBindableTypedArray(srcTypedArray);
|
||||
const pRet = wasm.alloc(srcTypedArray.byteLength || 1);
|
||||
wasm.heapForSize(srcTypedArray.constructor).set(
|
||||
@@ -943,15 +945,16 @@ self.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
|
||||
the range of supported argument types. */
|
||||
["sqlite3_realloc", "*","*","int"],
|
||||
["sqlite3_reset", "int", "sqlite3_stmt*"],
|
||||
["sqlite3_result_blob",undefined, "*", "*", "int", "*"],
|
||||
["sqlite3_result_double",undefined, "*", "f64"],
|
||||
["sqlite3_result_error",undefined, "*", "string", "int"],
|
||||
["sqlite3_result_error_code", undefined, "*", "int"],
|
||||
["sqlite3_result_error_nomem", undefined, "*"],
|
||||
["sqlite3_result_error_toobig", undefined, "*"],
|
||||
["sqlite3_result_int",undefined, "*", "int"],
|
||||
["sqlite3_result_null",undefined, "*"],
|
||||
["sqlite3_result_text",undefined, "*", "string", "int", "*"],
|
||||
["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_text",undefined, "sqlite3_context*", "string", "int", "*"],
|
||||
["sqlite3_result_zeroblob", undefined, "sqlite3_context*", "int"],
|
||||
["sqlite3_serialize","*", "sqlite3*", "string", "*", "int"],
|
||||
["sqlite3_shutdown", undefined],
|
||||
["sqlite3_sourceid", "string"],
|
||||
@@ -999,6 +1002,7 @@ self.sqlite3ApiBootstrap = function sqlite3ApiBootstrap(
|
||||
["sqlite3_msize", "i64", "*"],
|
||||
["sqlite3_realloc64", "*","*", "i64"],
|
||||
["sqlite3_result_int64",undefined, "*", "i64"],
|
||||
["sqlite3_result_zeroblob64", "int", "*", "i64"],
|
||||
["sqlite3_total_changes64", "i64", ["sqlite3*"]],
|
||||
["sqlite3_uri_int64", "i64", ["sqlite3_filename", "string", "i64"]],
|
||||
["sqlite3_value_int64","i64", "sqlite3_value*"],
|
||||
|
||||
@@ -348,7 +348,9 @@ self.sqlite3InitModule = sqlite3InitModule;
|
||||
name: "JS wasm-side allocator",
|
||||
test: function(sqlite3){
|
||||
if(sqlite3.config.useStdAlloc){
|
||||
warn("Using system allocator. This violates the docs.");
|
||||
warn("Using system allocator. This violates the docs and",
|
||||
"may cause grief with certain APIs",
|
||||
"(e.g. sqlite3_deserialize()).");
|
||||
T.assert(wasm.alloc.impl === wasm.exports.malloc)
|
||||
.assert(wasm.dealloc === wasm.exports.free)
|
||||
.assert(wasm.realloc.impl === wasm.exports.realloc);
|
||||
@@ -463,6 +465,12 @@ self.sqlite3InitModule = sqlite3InitModule;
|
||||
.assert(u[i] === w.getMemValue(m + i, 'i8'));
|
||||
}
|
||||
w.dealloc(m);
|
||||
m = w.allocFromTypedArray(u.buffer);
|
||||
for(let i = 0; i < u.length; ++i){
|
||||
T.assert(u[i] === byteList[i])
|
||||
.assert(u[i] === w.getMemValue(m + i, 'i8'));
|
||||
}
|
||||
w.dealloc(m);
|
||||
T.mustThrowMatching(
|
||||
()=>w.allocFromTypedArray(1),
|
||||
'Value is not of a supported TypedArray type.'
|
||||
@@ -1463,7 +1471,7 @@ self.sqlite3InitModule = sqlite3InitModule;
|
||||
const n = db.selectValue(sql);
|
||||
T.assert(n>0 && db2.selectValue(sql) === n);
|
||||
}finally{
|
||||
if(db2) db2.close();
|
||||
db2.close();
|
||||
wasm.sqlite3_wasm_vfs_unlink(pVfs, filename);
|
||||
}
|
||||
}
|
||||
@@ -1502,8 +1510,7 @@ self.sqlite3InitModule = sqlite3InitModule;
|
||||
assert(T.eqApprox(3.1,db.selectValue("select 3.0 + 0.1"))).
|
||||
assert(T.eqApprox(1.3,db.selectValue("select asis(1 + 0.3)")));
|
||||
|
||||
let blobArg = new Uint8Array(2);
|
||||
blobArg.set([0x68, 0x69], 0);
|
||||
let blobArg = new Uint8Array([0x68, 0x69]);
|
||||
let blobRc = db.selectValue("select asis(?1)", blobArg);
|
||||
T.assert(blobRc instanceof Uint8Array).
|
||||
assert(2 === blobRc.length).
|
||||
@@ -1513,8 +1520,7 @@ self.sqlite3InitModule = sqlite3InitModule;
|
||||
assert(2 === blobRc.length).
|
||||
assert(0x68==blobRc[0] && 0x69==blobRc[1]);
|
||||
|
||||
blobArg = new Int8Array(2);
|
||||
blobArg.set([0x68, 0x69]);
|
||||
blobArg = new Int8Array([0x68, 0x69]);
|
||||
//debug("blobArg=",blobArg);
|
||||
blobRc = db.selectValue("select asis(?1)", blobArg);
|
||||
T.assert(blobRc instanceof Uint8Array).
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
C For\sCLI\s.sha3sum,\semit\swarning\sto\sstderr\sfor\sany\sinvalidly\sencoded\stext\sfields.
|
||||
D 2022-12-06T18:48:37.123
|
||||
C Merge\sfrom\strunk\sprepratory\sto\sbranch\send.
|
||||
D 2022-12-06T19:25:07.478
|
||||
F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
|
||||
F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
|
||||
F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724
|
||||
@@ -289,9 +289,9 @@ F ext/misc/README.md d6dd0fe1d8af77040216798a6a2b0c46c73054d2f0ea544fbbcdccf6f23
|
||||
F ext/misc/amatch.c e3ad5532799cee9a97647f483f67f43b38796b84b5a8c60594fe782a4338f358
|
||||
F ext/misc/anycollseq.c 5ffdfde9829eeac52219136ad6aa7cd9a4edb3b15f4f2532de52f4a22525eddb
|
||||
F ext/misc/appendvfs.c 9642c7a194a2a25dca7ad3e36af24a0a46d7702168c4ad7e59c9f9b0e16a3824
|
||||
F ext/misc/base64.c fb140039d4e15710298e28cafe12d2bdff1b927fc57540cbcd07996f82bf9800 x
|
||||
F ext/misc/base64.c 1ad313d38dc081abe5a87fa51e44f07ec6cfb618aa9606a77e42bd2fe706a67f x
|
||||
F ext/misc/base85.c ace591246855806a70e63eb6705ce8736f4b782da2137bdbb5d39cc337346e0d
|
||||
F ext/misc/basexx.c b37ea21f00deea1029d2ddc670f5701d9370ae06f7d173c5bed79d0f26a67ec1
|
||||
F ext/misc/basexx.c 58f72b3c159e875bfd2d30a56254e7f2098961c31dc733773a9270de7066aa4c
|
||||
F ext/misc/blobio.c a867c4c4617f6ec223a307ebfe0eabb45e0992f74dd47722b96f3e631c0edb2a
|
||||
F ext/misc/btreeinfo.c d28ce349b40054eaa9473e835837bad7a71deec33ba13e39f963d50933bfa0f9
|
||||
F ext/misc/carray.c b752f46411e4e47e34dce6f0c88bc8e51bb821ba9e49bfcd882506451c928f69
|
||||
@@ -494,7 +494,7 @@ F ext/wasm/EXPORTED_FUNCTIONS.fiddle.in 27450c8b8c70875a260aca55435ec927068b34ce
|
||||
F ext/wasm/GNUmakefile bfa47f169468ca9db031105b0e336db29a88e93c3abd217d0bbb2b8731fa5413
|
||||
F ext/wasm/README-dist.txt 2d670b426fc7c613b90a7d2f2b05b433088fe65181abead970980f0a4a75ea20
|
||||
F ext/wasm/README.md ef39861aa21632fdbca0bdd469f78f0096f6449a720f3f39642594af503030e9
|
||||
F ext/wasm/api/EXPORTED_FUNCTIONS.sqlite3-api eeb1300945c3871e46904e026a04a41d6fc458fcaa74ccee4e719ebb8ccb3087
|
||||
F ext/wasm/api/EXPORTED_FUNCTIONS.sqlite3-api 89af0612bad5c651f69e629c7e9689be6d3c8a92a9010da5dd90a87c1d86817a
|
||||
F ext/wasm/api/EXPORTED_RUNTIME_METHODS.sqlite3-api 1ec3c73e7d66e95529c3c64ac3de2470b0e9e7fbf7a5b41261c367cf4f1b7287
|
||||
F ext/wasm/api/README.md 20a256f4aaae80035d2bb1c9e3e0a125570313a8d137d427471d7be10edde87a
|
||||
F ext/wasm/api/extern-post-js.c-pp.js 8923f76c3d2213159e12d641dc750523ead5c848185dc4996fae5cc12397f88d
|
||||
@@ -505,7 +505,7 @@ F ext/wasm/api/pre-js.c-pp.js b88499dc303c21fc3f55f2c364a0f814f587b60a9578430388
|
||||
F ext/wasm/api/sqlite3-api-cleanup.js 680d5ccfff54459db136a49b2199d9f879c8405d9c99af1dda0cc5e7c29056f4
|
||||
F ext/wasm/api/sqlite3-api-glue.js 6fe39964605fda3b699f69365eed565b5172d29cab2c49bc057a43f9a93f9f36
|
||||
F ext/wasm/api/sqlite3-api-oo1.js 91a7d7b9203fb0f031e6ba380a644a7f871e1798b388de399c01ed4087bac9e0
|
||||
F ext/wasm/api/sqlite3-api-prologue.js b06eb09246deb56612b4905eb2ec4bcc8b10f0472fa661cd54c5d6cd1888d8b9
|
||||
F ext/wasm/api/sqlite3-api-prologue.js 697a5989ad52a9ba7bc60b5436589bd05885ee2201d84c38c5e9af3876af3ba4
|
||||
F ext/wasm/api/sqlite3-api-worker1.js e94ba98e44afccfa482874cd9acb325883ade50ed1f9f9526beb9de1711f182f
|
||||
F ext/wasm/api/sqlite3-license-version-header.js a661182fc93fc2cf212dfd0b987f8e138a3ac98f850b1112e29b5fbdaecc87c3
|
||||
F ext/wasm/api/sqlite3-opfs-async-proxy.js f79dd8d98ef3e0b55c10bb2bee7a3840fa967318e1f577c156aafc34664271d1
|
||||
@@ -555,7 +555,7 @@ F ext/wasm/test-opfs-vfs.html 1f2d672f3f3fce810dfd48a8d56914aba22e45c6834e262555
|
||||
F ext/wasm/test-opfs-vfs.js 44363db07b2a20e73b0eb1808de4400ca71b703af718d0fa6d962f15e73bf2ac
|
||||
F ext/wasm/tester1-worker.html 29b1d87f7d51f70d61645719fee657f3787fe939bb695f27034c75404e8f1e6f
|
||||
F ext/wasm/tester1.c-pp.html 74aa9b31c75f12490653f814b53c3dd39f40cd3f70d6a53a716f4e8587107399
|
||||
F ext/wasm/tester1.c-pp.js 956acfd5675e61fa7c52a19e5b16603da61e753e309abe91284e3b1d39598840
|
||||
F ext/wasm/tester1.c-pp.js d096a8fadfd27caa680a4311b1d529551f8fe885a63dd27457c87b6008c64632
|
||||
F ext/wasm/tests/opfs/concurrency/index.html 86d8ac435074d1e7007b91105f4897f368c165e8cecb6a9aa3d81f5cf5dcbe70
|
||||
F ext/wasm/tests/opfs/concurrency/test.js a98016113eaf71e81ddbf71655aa29b0fed9a8b79a3cdd3620d1658eb1cc9a5d
|
||||
F ext/wasm/tests/opfs/concurrency/worker.js 0a8c1a3e6ebb38aabbee24f122693f1fb29d599948915c76906681bb7da1d3d2
|
||||
@@ -595,14 +595,14 @@ F src/date.c 94ce83b4cd848a387680a5f920c9018c16655db778c4d36525af0a0f34679ac5
|
||||
F src/dbpage.c f1a87f4ebcf22284e0aaf0697862f4ccfc120dcd6db3d8dfa3b049b2580c01d8
|
||||
F src/dbstat.c a56a7ad1163a9888d46cd5820be2e65354fb1aa04ed6909f7c3e5831e0ee2c29
|
||||
F src/delete.c 86573edae75e3d3e9a8b590d87db8e47222103029df4f3e11fa56044459b514e
|
||||
F src/expr.c 9e7fadc664b938c18f006be0d4f6669888f9302756ee204420c7eccaed5435a6
|
||||
F src/expr.c d0ce060008452653e9c7bcdce8b1e3ff078fbbd5f9f80b530b3ab99bb70a8078
|
||||
F src/fault.c 460f3e55994363812d9d60844b2a6de88826e007
|
||||
F src/fkey.c 722f20779f5342a787922deded3628d8c74b5249cab04098cf17ee2f2aaff002
|
||||
F src/func.c 7e86074afc4dc702691a29b7801f6dcc191db092b52e8bbe69dcd2f7be52194d
|
||||
F src/global.c e06ff8e0acd85aec13563c9ecb44fbbf38232ccf73594998fd880b92d619594b
|
||||
F src/hash.c 8d7dda241d0ebdafb6ffdeda3149a412d7df75102cecfc1021c98d6219823b19
|
||||
F src/hash.h 3340ab6e1d13e725571d7cee6d3e3135f0779a7d8e76a9ce0a85971fa3953c51
|
||||
F src/hwtime.h cb1d7e3e1ed94b7aa6fde95ae2c2daccc3df826be26fc9ed7fd90d1750ae6144
|
||||
F src/hwtime.h b638809e083b601b618df877b2e89cb87c2a47a01f4def10be4c4ebb54664ac7
|
||||
F src/in-operator.md 10cd8f4bcd225a32518407c2fb2484089112fd71
|
||||
F src/insert.c 1b11a2e33ee52db93c02fddac67e39d00161d61b69fac2675b82f2aa68c1b61c
|
||||
F src/json.c 7749b98c62f691697c7ee536b570c744c0583cab4a89200fdd0fc2aa8cc8cbd6
|
||||
@@ -615,7 +615,7 @@ F src/mem1.c c12a42539b1ba105e3707d0e628ad70e611040d8f5e38cf942cee30c867083de
|
||||
F src/mem2.c c8bfc9446fd0798bddd495eb5d9dbafa7d4b7287d8c22d50a83ac9daa26d8a75
|
||||
F src/mem3.c 30301196cace2a085cbedee1326a49f4b26deff0af68774ca82c1f7c06fda4f6
|
||||
F src/mem5.c 5a3dbd8ac8a6501152a4fc1fcae9b0900c2d7eb0589c4ec7456fdde15725a26c
|
||||
F src/memdb.c a42248bc04dc1f80da3511618a78956ed77b65058b73e251bde39061204e9f97
|
||||
F src/memdb.c fa280078fb48c4bb7ef47e361cd958938a1a3c46a9a45f6622da6efcb57cc055
|
||||
F src/memjournal.c c283c6c95d940eb9dc70f1863eef3ee40382dbd35e5a1108026e7817c206e8a0
|
||||
F src/msvc.h 3a15918220367a8876be3fa4f2abe423a861491e84b864fb2b7426bf022a28f8
|
||||
F src/mutex.c 5e3409715552348732e97b9194abe92fdfcd934cfb681df4ba0ab87ac6c18d25
|
||||
@@ -629,7 +629,7 @@ F src/os.h 1ff5ae51d339d0e30d8a9d814f4b8f8e448169304d83a7ed9db66a65732f3e63
|
||||
F src/os_common.h 6c0eb8dd40ef3e12fe585a13e709710267a258e2c8dd1c40b1948a1d14582e06
|
||||
F src/os_kv.c 73f89ab97ecdb3216857d2acc8395103f89164eaadac87cce4e9e16445c89541
|
||||
F src/os_setup.h 6011ad7af5db4e05155f385eb3a9b4470688de6f65d6166b8956e58a3d872107
|
||||
F src/os_unix.c 08191111a7040b8d5a6fff946f9fc9a11a0f83bac727c0415dfc5d030e1bc41f
|
||||
F src/os_unix.c 60787ed9f2492a9f2f0ca5cca2d80cdbfd6e8f45a1b1560790ff39c9dfc680c0
|
||||
F src/os_win.c 295fe45f18bd86f2477f4cd79f3377c6f883ceb941b1f46808665c73747f2345
|
||||
F src/os_win.h 7b073010f1451abe501be30d12f6bc599824944a
|
||||
F src/pager.c d3122cf67f327f1e2df12d06236a3473a8099542071e257067552f42917f172d
|
||||
@@ -645,17 +645,17 @@ F src/printf.c e99ee9741e79ae3873458146f59644276657340385ade4e76a5f5d1c25793764
|
||||
F src/random.c 606b00941a1d7dd09c381d3279a058d771f406c5213c9932bbd93d5587be4b9c
|
||||
F src/resolve.c efea4e5fbecfd6d0a9071b0be0d952620991673391b6ffaaf4c277b0bb674633
|
||||
F src/rowset.c ba9515a922af32abe1f7d39406b9d35730ed65efab9443dc5702693b60854c92
|
||||
F src/select.c 6983de0e6b8b68c97f82f9fca27ffb8f17161cff4d0d48fdf9eb40b213da0cc6
|
||||
F src/shell.c.in cf32c16e1b4ff8e434b51fe38753bfddccd75d4a3ecb1fb838a6f96a70e2ff3a
|
||||
F src/sqlite.h.in 3439711b72cf1a541716da3671ac40f8d5957cdecfc192d47d32f7aed94207c2
|
||||
F src/select.c 56162cde2f71314826f831618eae853205628080afa25cd90faef7a9b761dee4
|
||||
F src/shell.c.in b5bc6e14605b8d1e8de729454d98d3353ad7e529a8d2b6e34080d068e99bff99
|
||||
F src/sqlite.h.in 1fe1836879ecbb2e28f00f44eb6092db09a2a06bf072af351c6c2466bd515496
|
||||
F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
|
||||
F src/sqlite3ext.h c4b9fa7a7e2bcdf850cfeb4b8a91d5ec47b7a00033bc996fd2ee96cbf2741f5f
|
||||
F src/sqliteInt.h 4ddd98e423276714479f9f22dbbda050e8ef99aa97e7e26bf0bdf58acef0ca42
|
||||
F src/sqliteInt.h 0c9934acd88e0fa14f0d4743233b4cd7bd7bbc84099ba3cad50d8e69676ce2b9
|
||||
F src/sqliteLimit.h d7323ffea5208c6af2734574bae933ca8ed2ab728083caa117c9738581a31657
|
||||
F src/status.c 160c445d7d28c984a0eae38c144f6419311ed3eace59b44ac6dafc20db4af749
|
||||
F src/table.c 0f141b58a16de7e2fbe81c308379e7279f4c6b50eb08efeec5892794a0ba30d1
|
||||
F src/tclsqlite.c 4e64ba300a5a26e0f1170e09032429faeb65e45e8f3d1a7833e8edb69fc2979e
|
||||
F src/test1.c 09ad3f2bf5f0efe70eb16e460054954b36be8ed09dfcafa0642b37d25d379f6f
|
||||
F src/test1.c 98f4a4525e10b0df164ba7f33950824348bb29fd582101e0f93b1af72f493154
|
||||
F src/test2.c 827446e259a3b7ab949da1542953edda7b5117982576d3e6f1c24a0dd20a5cef
|
||||
F src/test3.c 61798bb0d38b915067a8c8e03f5a534b431181f802659a6616f9b4ff7d872644
|
||||
F src/test4.c 4533b76419e7feb41b40582554663ed3cd77aaa54e135cf76b3205098cd6e664
|
||||
@@ -672,7 +672,7 @@ F src/test_blob.c ae4a0620b478548afb67963095a7417cd06a4ec0a56adb453542203bfdcb31
|
||||
F src/test_btree.c 8b2dc8b8848cf3a4db93f11578f075e82252a274
|
||||
F src/test_config.c 8264637b06a3c1f0727c88d1ea32dcf7986b9e7e358a970cae87cdac8a5b2708
|
||||
F src/test_delete.c e2fe07646dff6300b48d49b2fee2fe192ed389e834dd635e3b3bac0ce0bf9f8f
|
||||
F src/test_demovfs.c 7cc7623d1025d1e92c51da20fd25060759733b7a356a121545a3b7d2faa8a0f1
|
||||
F src/test_demovfs.c 38a459d1c78fd9afa770445b224c485e079018d6ac07332ff9bd07b54d2b8ce9
|
||||
F src/test_devsym.c aff2255ea290d7718da08af30cdf18e470ff7325a5eff63e0057b1496ed66593
|
||||
F src/test_fs.c ba1e1dc18fd3159fdba0b9c4256f14032159785320dfbd6776eb9973cb75d480
|
||||
F src/test_func.c 24df3a346c012b1fc9e1001d346db6054deb426db0a7437e92490630e71c9b0a
|
||||
@@ -715,13 +715,13 @@ F src/trigger.c 5e68b790f022b8dafbfb0eb244786512a95c9575fc198719d2557d73e5795858
|
||||
F src/update.c 5b0302c47cf31b533d5dff04c497ca1d8b9d89c39727e633fbe7b882fd5ac5aa
|
||||
F src/upsert.c 5303dc6c518fa7d4b280ec65170f465c7a70b7ac2b22491598f6d0b4875b3145
|
||||
F src/utf.c ee39565f0843775cc2c81135751ddd93eceb91a673ea2c57f61c76f288b041a0
|
||||
F src/util.c 4e42c338d982e3f139004467bf0f2e9d679d519c7c75718fcf4ff1811401b03c
|
||||
F src/util.c 313f3154e2b85a447326f5dd15de8d31a4df6ab0c3579bd58f426ff634ec9050
|
||||
F src/vacuum.c 84ce7f01f8a7a08748e107a441db83bcec13970190ddcb0c9ff522adbc1c23fd
|
||||
F src/vdbe.c 00648bd76fb2145c2d890312112bda446569da64ca70aaf1f2282cc6c2b22d14
|
||||
F src/vdbe.h 58675f47dcf3105bab182c3ad3726efd60ffd003e954386904ac9107d0d2b743
|
||||
F src/vdbeInt.h 17b7461ffcf9ee760d1341731715a419f6b8c763089a7ece25c2e8098d702b3f
|
||||
F src/vdbeapi.c b75fe402b8c0db8839aa9968f917bae49361a364ed28069b27b19ac7761e48b0
|
||||
F src/vdbeaux.c 8ebe337e82d99cf3b01cd4fd67103a5b0054d53fee8456b90dbeba46ebf97ceb
|
||||
F src/vdbe.c 8fdef91d3c9bfa363e8eb381d362e2f0cadec456975ec5595c0bfdf65da84e53
|
||||
F src/vdbe.h 6d921884cf8ec6a53efba99f8b68e32e955367631743e29039840e781aaf547c
|
||||
F src/vdbeInt.h e83be1eea422758d42302941e96e59d93193c373da655a87befdc03a851e0f95
|
||||
F src/vdbeapi.c 5e265ab5165b0dfeac55e6a2ad3929d64584c4e7ca106b438137d7596da91348
|
||||
F src/vdbeaux.c 0b81f317c86ed9f4ba822af66a52777fed6e8180edc79d4fc62ffe75c8e52d80
|
||||
F src/vdbeblob.c 5e61ce31aca17db8fb60395407457a8c1c7fb471dde405e0cd675974611dcfcd
|
||||
F src/vdbemem.c 6cfed43758d57b6e3b99d9cdedfeccd86e45a07e427b22d8487cbdbebb6c522a
|
||||
F src/vdbesort.c 43756031ca7430f7aec3ef904824a7883c4ede783e51f280d99b9b65c0796e35
|
||||
@@ -732,9 +732,9 @@ F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
|
||||
F src/wal.c b9df133a705093da8977da5eb202eaadb844839f1c7297c08d33471f5491843d
|
||||
F src/wal.h c3aa7825bfa2fe0d85bef2db94655f99870a285778baa36307c0a16da32b226a
|
||||
F src/walker.c f890a3298418d7cba3b69b8803594fdc484ea241206a8dfa99db6dd36f8cbb3b
|
||||
F src/where.c bf470b5d1ba03af8d558a0c98cc1fa97b330e03a198a7af61895e5a2e8d93f20
|
||||
F src/where.c 20f4f51d2d5fb19b984e6ea381b26cf627cc93e64dd9b2ce6a94531aec2f5916
|
||||
F src/whereInt.h e25203e5bfee149f5f1225ae0166cfb4f1e65490c998a024249e98bb0647377c
|
||||
F src/wherecode.c ee52c2781c36004d23c85bf111063b78fc16e5e1b6a0d424326af8bf90babb0b
|
||||
F src/wherecode.c 76bca3379219880d2527493b71a3be49e696f75396d3481e4de5d4ceec7886b2
|
||||
F src/whereexpr.c 05295b44b54eea76d1ba766f0908928d0e20e990c249344c9521454d3d09c7ae
|
||||
F src/window.c 14836767adb26573b50f528eb37f8b1336f2c430ab38de7cead1e5c546bb4d8c
|
||||
F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
|
||||
@@ -1317,6 +1317,7 @@ F test/manydb.test 28385ae2087967aa05c38624cec7d96ec74feb3e
|
||||
F test/mem5.test c6460fba403c5703141348cd90de1c294188c68f
|
||||
F test/memdb.test c1f2a343ad14398d5d6debda6ea33e80d0dafcc7
|
||||
F test/memdb1.test 2c4e9cc10d21c6bf4e217d72b7f6b8ba9b2605971bb2c5e6df76018e189f98f5
|
||||
F test/memdb2.test d1dc6058ee59f78c7f46f85e069bb974a981920f8c499f0167690d16c0b079f6
|
||||
F test/memjournal.test 70f3a00c7f84ee2978ad14e831231caa1e7f23915a2c54b4f775a021d5740c6c
|
||||
F test/memjournal2.test 6b9083cfaab9a3281ec545c3da2487999e8025fb7501bbae10f713f80c56454c
|
||||
F test/memleak.test 10b9c6c57e19fc68c32941495e9ba1c50123f6e2
|
||||
@@ -1368,7 +1369,7 @@ F test/openv2.test 0d3040974bf402e19b7df4b783e447289d7ab394
|
||||
F test/optfuzz-db01.c 9f2fa80b8f84ebbf1f2e8b13421a4e0477fe300f6686fbd76cac1d2db66e0fdc
|
||||
F test/optfuzz-db01.txt 21f6bdeadc701cf11528276e2a55c70bfcb846ba42df327f979bd9e7b6ce7041
|
||||
F test/optfuzz.c 690430a0bf0ad047d5a168bf52b05b2ee97aedaad8c14337e9eb5050faa64994
|
||||
F test/orderby1.test a4bba04b9c60a21e53486fbc173a596b29641a3b3a57a0f26a1cbef1360358e9
|
||||
F test/orderby1.test 02cfd870127a7342170b829175c5c53e9e7405744451ac1aeb2f7e2b0c18ca76
|
||||
F test/orderby2.test bc11009f7cd99d96b1b11e57b199b00633eb5b04
|
||||
F test/orderby3.test 8619d06a3debdcd80a27c0fdea5c40b468854b99
|
||||
F test/orderby4.test 4d39bfbaaa3ae64d026ca2ff166353d2edca4ba4
|
||||
@@ -1456,7 +1457,8 @@ F test/savepoint5.test 0735db177e0ebbaedc39812c8d065075d563c4fd
|
||||
F test/savepoint6.test f41279c5e137139fa5c21485773332c7adb98cd7
|
||||
F test/savepoint7.test cde525ea3075283eb950cdcdefe23ead4f700daa
|
||||
F test/savepointfault.test f044eac64b59f09746c7020ee261734de82bf9b2
|
||||
F test/scanstatus.test 9a0ed37ab6d57b50567282788fffdf832d9b16739ecc41bff9d77a8d767cf317
|
||||
F test/scanstatus.test 7dbcfd6adc6a8df6abc59f83d6da5a27e1bce0b2f6fa55147c8176d7c44e0450
|
||||
F test/scanstatus2.test 3f45ec1d8b45dcb0df7f98daf3364fc2e03bf89a8c3dd2428251a5e0a34de7af
|
||||
F test/schema.test 5dd11c96ba64744de955315d2e4f8992e447533690153b93377dffb2a5ef5431
|
||||
F test/schema2.test 906408621ea881fdb496d878b1822572a34e32c5
|
||||
F test/schema3.test 8ed4ae66e082cdd8b1b1f22d8549e1e7a0db4527a8e6ee8b6193053ee1e5c9ce
|
||||
@@ -1500,7 +1502,7 @@ F test/sharedB.test 1a84863d7a2204e0d42f2e1606577c5e92e4473fa37ea0f5bdf829e4bf8e
|
||||
F test/shared_err.test 32634e404a3317eeb94abc7a099c556a346fdb8fb3858dbe222a4cbb8926a939
|
||||
F test/sharedlock.test 5ede3c37439067c43b0198f580fd374ebf15d304
|
||||
F test/shell1.test e4b4de56f454708e0747b52915135baa2cbfec4965406d6eaf02a4a5c22a9880
|
||||
F test/shell2.test c536c2aab4852608f8a606262330797abc4d964a4c2c782a7760f54ea1f17a6a
|
||||
F test/shell2.test 1190b951373fdfe719bc6ac16962bc743dfa4355db8ae546c0bb9bf559a28d4a
|
||||
F test/shell3.test 91febeac0412812bf6370abb8ed72700e32bf8f9878849414518f662dfd55e8a
|
||||
F test/shell4.test 9abd0c12a7e20a4c49e84d5be208d2124fa6c09e728f56f1f4bee0f02853935f
|
||||
F test/shell5.test c8b6c54f26ec537f8558273d7ed293ca3725ef42e6b12b8f151718628bd1473b
|
||||
@@ -1525,7 +1527,7 @@ F test/snapshot_fault.test f6c5ef7cb93bf92fbb4e864ecc5c87df7d3a250064838822db5b4
|
||||
F test/snapshot_up.test a0a29c4cf33475fcef07c3f8e64af795e24ab91b4cc68295863402a393cdd41c
|
||||
F test/soak.test 18944cf21b94a7fe0df02016a6ee1e9632bc4e8d095a0cb49d95e15d5cca2d5c
|
||||
F test/softheap1.test 843cd84db9891b2d01b9ab64cef3e9020f98d087
|
||||
F test/sort.test c2adc635c2564241fefec0b3a68391ef6868fd3b
|
||||
F test/sort.test f86751134159abb5e5fd4381a0d7038c91013638cd1e3fa1d7850901f6df6196
|
||||
F test/sort2.test cc23b7c19d684657559e8a55b02f7fcee03851d0
|
||||
F test/sort3.test 1480ed7c4c157682542224e05e3b75faf4a149e5
|
||||
F test/sort4.test 5c34d9623a4ae5921d956dfa2b70e77ed0fc6e5c
|
||||
@@ -1884,7 +1886,7 @@ F test/walthread.test 14b20fcfa6ae152f5d8e12f5dc8a8a724b7ef189f5d8ef1e2ceab79f2a
|
||||
F test/walvfs.test e1a6ad0f3c78e98b55c3d5f0889cf366cc0d0a1cb2bccb44ac9ec67384adc4a1
|
||||
F test/wapp.tcl b440cd8cf57953d3a49e7ee81e6a18f18efdaf113b69f7d8482b0710a64566ec
|
||||
F test/wapptest.tcl 1bea58a6a8e68a73f542ee4fca28b771b84ed803bd0c9e385087070b3d747b3c x
|
||||
F test/where.test d13cd7c24e80009d2b54e2f7a8893c457afa49c64f99359c9eb3fe668ba1d9d4
|
||||
F test/where.test 98208c95b574269980132c347b4bdb8992c6d5fc30c1954938593336d12e7447
|
||||
F test/where2.test 03c21a11e7b90e2845fc3c8b4002fc44cc2797fa74c86ee47d70bd7ea4f29ed6
|
||||
F test/where3.test 5b4ffc0ac2ea0fe92f02b1244b7531522fe4d7bccf6fa8741d54e82c10e67753
|
||||
F test/where4.test 4a371bfcc607f41d233701bdec33ac2972908ba8
|
||||
@@ -1994,7 +1996,7 @@ F tool/mkctimec.tcl c185cf1bdcd3d9bd3c06f77a2fd2df8a4a0d07266f992ecda75286965ba3
|
||||
F tool/mkkeywordhash.c 35bfc41adacc4aa6ef6fca7fd0c63e0ec0534b78daf4d0cfdebe398216bbffc3
|
||||
F tool/mkmsvcmin.tcl 6ecab9fe22c2c8de4d82d4c46797bda3d2deac8e763885f5a38d0c44a895ab33
|
||||
F tool/mkopcodec.tcl 33d20791e191df43209b77d37f0ff0904620b28465cca6990cf8d60da61a07ef
|
||||
F tool/mkopcodeh.tcl bcb2bd5affb545fd219ef0304c7978e2a356407ab723f45ec8569235892c1c3f
|
||||
F tool/mkopcodeh.tcl 769d9e6a8b462323150dc13a8539d6064664b72974f7894befe2491cc73e05cd
|
||||
F tool/mkopts.tcl 680f785fdb09729fd9ac50632413da4eadbdf9071535e3f26d03795828ab07fa
|
||||
F tool/mkpragmatab.tcl bd07bd59d45d0f3448e123d6937e9811195f9908a51e09d774609883055bfd3d
|
||||
F tool/mkshellc.tcl 02d0de8349ef830c0fb20d29680320bde2466e2ec422e5bd94c4317a7a7e8cc9
|
||||
@@ -2040,7 +2042,7 @@ F tool/symbols-mingw.sh 4dbcea7e74768305384c9fd2ed2b41bbf9f0414d
|
||||
F tool/symbols.sh 1612bd947750e21e7b47befad5f6b3825b06cce0705441f903bf35ced65ae9b9
|
||||
F tool/varint.c 5d94cb5003db9dbbcbcc5df08d66f16071aee003
|
||||
F tool/vdbe-compress.tcl 1dcb7632e57cf57105248029e6e162fddaf6c0fccb3bb9e6215603752c5a2d4a
|
||||
F tool/vdbe_profile.tcl 246d0da094856d72d2c12efec03250d71639d19f
|
||||
F tool/vdbe_profile.tcl 3ac5a4a9449f4baf77059358ea050db3e34395ccf59c5464d29b91746d5b961e
|
||||
F tool/warnings-clang.sh bbf6a1e685e534c92ec2bfba5b1745f34fb6f0bc2a362850723a9ee87c1b31a7
|
||||
F tool/warnings.sh d58dc38367cc776550f90327e205d7946802d4004fb9f291fd8b81256bc1eedd
|
||||
F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
|
||||
@@ -2065,8 +2067,8 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
|
||||
F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
|
||||
F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
|
||||
F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
|
||||
P 123f2a0785790addf9c60a0fd09077dda9cb84d33a2594901a2b22bb555be491
|
||||
R 1a108a993a6e5c4e1463804542f95600
|
||||
P 8e833ecc81367658e81acd1d3a0242ab954a62d6f719af56f1d185656d0b73e6 9499b2f51e8174c6b8a67840c92ba23b7dd1dc8dc2b91fca0c5dc07b71662149 03ae8680e430c6d2c39ca26fa2cb6eed46e3c3e52b53f7a8bf548560446c6d3d
|
||||
R 2aee8123cf630f6dc747669c6dfb6cfe
|
||||
U larrybr
|
||||
Z 23502144cb7b8e35b977c4658f2c6efa
|
||||
Z 454f785f671f223a15f2524ef9698b47
|
||||
# Remove this line to create a well-formed Fossil manifest.
|
||||
|
||||
+1
-1
@@ -1 +1 @@
|
||||
8e833ecc81367658e81acd1d3a0242ab954a62d6f719af56f1d185656d0b73e6
|
||||
1d01f8483af7b6a4e93a49fd8bbb6a2b9300e969b574efeb96d56081a33055c4
|
||||
+6
-1
@@ -3257,6 +3257,9 @@ int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
|
||||
SelectDest dest; /* How to deal with SELECT result */
|
||||
int nReg; /* Registers to allocate */
|
||||
Expr *pLimit; /* New limit expression */
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
int addrExplain; /* Address of OP_Explain instruction */
|
||||
#endif
|
||||
|
||||
Vdbe *v = pParse->pVdbe;
|
||||
assert( v!=0 );
|
||||
@@ -3309,8 +3312,9 @@ int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
|
||||
** In both cases, the query is augmented with "LIMIT 1". Any
|
||||
** preexisting limit is discarded in place of the new LIMIT 1.
|
||||
*/
|
||||
ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY %d",
|
||||
ExplainQueryPlan2(addrExplain, (pParse, 1, "%sSCALAR SUBQUERY %d",
|
||||
addrOnce?"":"CORRELATED ", pSel->selId));
|
||||
sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, -1);
|
||||
nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
|
||||
sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
|
||||
pParse->nMem += nReg;
|
||||
@@ -3353,6 +3357,7 @@ int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
|
||||
if( addrOnce ){
|
||||
sqlite3VdbeJumpHere(v, addrOnce);
|
||||
}
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
|
||||
|
||||
/* Subroutine return */
|
||||
assert( ExprUseYSub(pExpr) );
|
||||
|
||||
+3
-3
@@ -48,9 +48,9 @@
|
||||
#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))
|
||||
|
||||
__inline__ sqlite_uint64 sqlite3Hwtime(void){
|
||||
unsigned long val;
|
||||
__asm__ __volatile__ ("rdtsc" : "=A" (val));
|
||||
return val;
|
||||
unsigned int lo, hi;
|
||||
__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
|
||||
return (sqlite_uint64)hi << 32 | lo;
|
||||
}
|
||||
|
||||
#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))
|
||||
|
||||
+13
@@ -371,9 +371,22 @@ static int memdbLock(sqlite3_file *pFile, int eLock){
|
||||
if( eLock==pThis->eLock ) return SQLITE_OK;
|
||||
memdbEnter(p);
|
||||
if( eLock>SQLITE_LOCK_SHARED ){
|
||||
assert( pThis->eLock>=SQLITE_LOCK_SHARED );
|
||||
if( p->mFlags & SQLITE_DESERIALIZE_READONLY ){
|
||||
rc = SQLITE_READONLY;
|
||||
}else if( eLock==SQLITE_LOCK_EXCLUSIVE ){
|
||||
/* Taking an EXCLUSIVE lock. Fail if we only have SHARED and any
|
||||
** other client has any kind of write-lock. Also fail if any other
|
||||
** client is holding read-lock. */
|
||||
if( pThis->eLock<=SQLITE_LOCK_SHARED && p->nWrLock ){
|
||||
rc = SQLITE_BUSY;
|
||||
}else if( p->nRdLock>1 ){
|
||||
rc = SQLITE_BUSY;
|
||||
}
|
||||
p->nWrLock = 1;
|
||||
}else if( pThis->eLock<=SQLITE_LOCK_SHARED ){
|
||||
/* Upgrading to RESERVED or PENDING from SHARED. Fail if any other
|
||||
** client has a write-lock of any kind. */
|
||||
if( p->nWrLock ){
|
||||
rc = SQLITE_BUSY;
|
||||
}else{
|
||||
|
||||
@@ -686,6 +686,9 @@ static int robust_open(const char *z, int f, mode_t m){
|
||||
break;
|
||||
}
|
||||
if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break;
|
||||
if( (f & (O_EXCL|O_CREAT))==(O_EXCL|O_CREAT) ){
|
||||
(void)osUnlink(z);
|
||||
}
|
||||
osClose(fd);
|
||||
sqlite3_log(SQLITE_WARNING,
|
||||
"attempt to open \"%s\" as file descriptor %d", z, fd);
|
||||
|
||||
+39
-4
@@ -65,6 +65,10 @@ struct SortCtx {
|
||||
} aDefer[4];
|
||||
#endif
|
||||
struct RowLoadInfo *pDeferredRowLoad; /* Deferred row loading info or NULL */
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
int addrPush; /* First instruction to push data into sorter */
|
||||
int addrPushEnd; /* Last instruction that pushes data into sorter */
|
||||
#endif
|
||||
};
|
||||
#define SORTFLAG_UseSorter 0x01 /* Use SorterOpen instead of OpenEphemeral */
|
||||
|
||||
@@ -721,6 +725,10 @@ static void pushOntoSorter(
|
||||
*/
|
||||
assert( nData==1 || regData==regOrigData || regOrigData==0 );
|
||||
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
pSort->addrPush = sqlite3VdbeCurrentAddr(v);
|
||||
#endif
|
||||
|
||||
if( nPrefixReg ){
|
||||
assert( nPrefixReg==nExpr+bSeq );
|
||||
regBase = regData - nPrefixReg;
|
||||
@@ -821,6 +829,9 @@ static void pushOntoSorter(
|
||||
sqlite3VdbeChangeP2(v, iSkip,
|
||||
pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
|
||||
}
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
pSort->addrPushEnd = sqlite3VdbeCurrentAddr(v)-1;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1647,6 +1658,16 @@ static void generateSortTail(
|
||||
int bSeq; /* True if sorter record includes seq. no. */
|
||||
int nRefKey = 0;
|
||||
struct ExprList_item *aOutEx = p->pEList->a;
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
int addrExplain; /* Address of OP_Explain instruction */
|
||||
#endif
|
||||
|
||||
ExplainQueryPlan2(addrExplain, (pParse, 0,
|
||||
"USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat>0?"RIGHT PART OF ":"")
|
||||
);
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd);
|
||||
sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush);
|
||||
|
||||
|
||||
assert( addrBreak<0 );
|
||||
if( pSort->labelBkOut ){
|
||||
@@ -1759,6 +1780,7 @@ static void generateSortTail(
|
||||
VdbeComment((v, "%s", aOutEx[i].zEName));
|
||||
}
|
||||
}
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
|
||||
switch( eDest ){
|
||||
case SRT_Table:
|
||||
case SRT_EphemTab: {
|
||||
@@ -1820,6 +1842,7 @@ static void generateSortTail(
|
||||
}else{
|
||||
sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
|
||||
}
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, sqlite3VdbeCurrentAddr(v)-1, -1);
|
||||
if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
|
||||
sqlite3VdbeResolveLabel(v, addrBreak);
|
||||
}
|
||||
@@ -7237,13 +7260,16 @@ int sqlite3Select(
|
||||
** set on each invocation.
|
||||
*/
|
||||
int addrTop = sqlite3VdbeCurrentAddr(v)+1;
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
int addrExplain;
|
||||
#endif
|
||||
|
||||
pItem->regReturn = ++pParse->nMem;
|
||||
sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
|
||||
VdbeComment((v, "%!S", pItem));
|
||||
pItem->addrFillSub = addrTop;
|
||||
sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
|
||||
ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem));
|
||||
ExplainQueryPlan2(addrExplain, (pParse, 1, "CO-ROUTINE %!S", pItem));
|
||||
sqlite3Select(pParse, pSub, &dest);
|
||||
pItem->pTab->nRowLogEst = pSub->nSelectRow;
|
||||
pItem->fg.viaCoroutine = 1;
|
||||
@@ -7251,6 +7277,10 @@ int sqlite3Select(
|
||||
sqlite3VdbeEndCoroutine(v, pItem->regReturn);
|
||||
sqlite3VdbeJumpHere(v, addrTop-1);
|
||||
sqlite3ClearTempRegCache(pParse);
|
||||
/* For SQLITE_SCANSTAT_NCYCLE, all instructions from the
|
||||
** OP_InitCoroutine coded above until this point are attributed to
|
||||
** the CO-ROUTINE query element. */
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain-1, -1);
|
||||
}else if( pItem->fg.isCte && pItem->u2.pCteUse->addrM9e>0 ){
|
||||
/* This is a CTE for which materialization code has already been
|
||||
** generated. Invoke the subroutine to compute the materialization,
|
||||
@@ -7277,6 +7307,9 @@ int sqlite3Select(
|
||||
** the same view can reuse the materialization. */
|
||||
int topAddr;
|
||||
int onceAddr = 0;
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
int addrExplain;
|
||||
#endif
|
||||
|
||||
pItem->regReturn = ++pParse->nMem;
|
||||
topAddr = sqlite3VdbeAddOp0(v, OP_Goto);
|
||||
@@ -7292,7 +7325,8 @@ int sqlite3Select(
|
||||
VdbeNoopComment((v, "materialize %!S", pItem));
|
||||
}
|
||||
sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
|
||||
ExplainQueryPlan((pParse, 1, "MATERIALIZE %!S", pItem));
|
||||
|
||||
ExplainQueryPlan2(addrExplain, (pParse, 1, "MATERIALIZE %!S", pItem));
|
||||
dest.zAffSdst = sqlite3TableAffinityStr(db, pItem->pTab);
|
||||
sqlite3Select(pParse, pSub, &dest);
|
||||
sqlite3DbFree(db, dest.zAffSdst);
|
||||
@@ -7310,6 +7344,9 @@ int sqlite3Select(
|
||||
pCteUse->iCur = pItem->iCursor;
|
||||
pCteUse->nRowEst = pSub->nSelectRow;
|
||||
}
|
||||
/* For SQLITE_SCANSTAT_NCYCLE, all instructions from the
|
||||
** OP_Explain to here are attibuted to the MATERIALIZE element. */
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
|
||||
}
|
||||
if( db->mallocFailed ) goto select_end;
|
||||
pParse->nHeight -= sqlite3SelectExprHeight(p);
|
||||
@@ -8055,8 +8092,6 @@ int sqlite3Select(
|
||||
** and send them to the callback one by one.
|
||||
*/
|
||||
if( sSort.pOrderBy ){
|
||||
explainTempTable(pParse,
|
||||
sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
|
||||
assert( p->pEList==pEList );
|
||||
generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
|
||||
}
|
||||
|
||||
+205
-42
@@ -467,8 +467,95 @@ static char *Argv0;
|
||||
** Prompt strings. Initialized in main. Settable with
|
||||
** .prompt main continue
|
||||
*/
|
||||
static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/
|
||||
static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */
|
||||
#define PROMPT_LEN_MAX 20
|
||||
/* First line prompt. default: "sqlite> " */
|
||||
static char mainPrompt[PROMPT_LEN_MAX];
|
||||
/* Continuation prompt. default: " ...> " */
|
||||
static char continuePrompt[PROMPT_LEN_MAX];
|
||||
|
||||
/*
|
||||
** Optionally disable dynamic continuation prompt.
|
||||
** Unless disabled, the continuation prompt shows open SQL lexemes if any,
|
||||
** or open parentheses level if non-zero, or continuation prompt as set.
|
||||
** This facility interacts with the scanner and process_input() where the
|
||||
** below 5 macros are used.
|
||||
*/
|
||||
#ifdef SQLITE_OMIT_DYNAPROMPT
|
||||
# define CONTINUATION_PROMPT continuePrompt
|
||||
# define CONTINUE_PROMPT_RESET
|
||||
# define CONTINUE_PROMPT_AWAITS(p,s)
|
||||
# define CONTINUE_PROMPT_AWAITC(p,c)
|
||||
# define CONTINUE_PAREN_INCR(p,n)
|
||||
# define CONTINUE_PROMPT_PSTATE 0
|
||||
typedef void *t_NoDynaPrompt;
|
||||
# define SCAN_TRACKER_REFTYPE t_NoDynaPrompt
|
||||
#else
|
||||
# define CONTINUATION_PROMPT dynamicContinuePrompt()
|
||||
# define CONTINUE_PROMPT_RESET \
|
||||
do {setLexemeOpen(&dynPrompt,0,0); trackParenLevel(&dynPrompt,0);} while(0)
|
||||
# define CONTINUE_PROMPT_AWAITS(p,s) \
|
||||
if(p && stdin_is_interactive) setLexemeOpen(p, s, 0)
|
||||
# define CONTINUE_PROMPT_AWAITC(p,c) \
|
||||
if(p && stdin_is_interactive) setLexemeOpen(p, 0, c)
|
||||
# define CONTINUE_PAREN_INCR(p,n) \
|
||||
if(p && stdin_is_interactive) (trackParenLevel(p,n))
|
||||
# define CONTINUE_PROMPT_PSTATE (&dynPrompt)
|
||||
typedef struct DynaPrompt *t_DynaPromptRef;
|
||||
# define SCAN_TRACKER_REFTYPE t_DynaPromptRef
|
||||
|
||||
static struct DynaPrompt {
|
||||
char dynamicPrompt[PROMPT_LEN_MAX];
|
||||
char acAwait[2];
|
||||
int inParenLevel;
|
||||
char *zScannerAwaits;
|
||||
} dynPrompt = { {0}, {0}, 0, 0 };
|
||||
|
||||
/* Record parenthesis nesting level change, or force level to 0. */
|
||||
static void trackParenLevel(struct DynaPrompt *p, int ni){
|
||||
p->inParenLevel += ni;
|
||||
if( ni==0 ) p->inParenLevel = 0;
|
||||
p->zScannerAwaits = 0;
|
||||
}
|
||||
|
||||
/* Record that a lexeme is opened, or closed with args==0. */
|
||||
static void setLexemeOpen(struct DynaPrompt *p, char *s, char c){
|
||||
if( s!=0 || c==0 ){
|
||||
p->zScannerAwaits = s;
|
||||
p->acAwait[0] = 0;
|
||||
}else{
|
||||
p->acAwait[0] = c;
|
||||
p->zScannerAwaits = p->acAwait;
|
||||
}
|
||||
}
|
||||
|
||||
/* Upon demand, derive the continuation prompt to display. */
|
||||
static char *dynamicContinuePrompt(void){
|
||||
if( continuePrompt[0]==0
|
||||
|| (dynPrompt.zScannerAwaits==0 && dynPrompt.inParenLevel == 0) ){
|
||||
return continuePrompt;
|
||||
}else{
|
||||
if( dynPrompt.zScannerAwaits ){
|
||||
int ncp = strlen(continuePrompt), ndp = strlen(dynPrompt.zScannerAwaits);
|
||||
if( ndp > ncp-3 ) return continuePrompt;
|
||||
strncpy(dynPrompt.dynamicPrompt, dynPrompt.zScannerAwaits, ndp);
|
||||
while( ndp<3 ) dynPrompt.dynamicPrompt[ndp++] = ' ';
|
||||
strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
|
||||
PROMPT_LEN_MAX-4);
|
||||
}else{
|
||||
if( dynPrompt.inParenLevel>9 ){
|
||||
strncpy(dynPrompt.dynamicPrompt, "(..", 4);
|
||||
}else if( dynPrompt.inParenLevel<0 ){
|
||||
strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
|
||||
}else{
|
||||
strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
|
||||
dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
|
||||
}
|
||||
strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3, PROMPT_LEN_MAX-4);
|
||||
}
|
||||
}
|
||||
return dynPrompt.dynamicPrompt;
|
||||
}
|
||||
#endif /* !defined(SQLITE_OMIT_DYNAPROMPT) */
|
||||
|
||||
/*
|
||||
** Render output like fprintf(). Except, if the output is going to the
|
||||
@@ -729,7 +816,7 @@ static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
|
||||
if( in!=0 ){
|
||||
zResult = local_getline(zPrior, in);
|
||||
}else{
|
||||
zPrompt = isContinuation ? continuePrompt : mainPrompt;
|
||||
zPrompt = isContinuation ? CONTINUATION_PROMPT : mainPrompt;
|
||||
#if SHELL_USE_LOCAL_GETLINE
|
||||
printf("%s", zPrompt);
|
||||
fflush(stdout);
|
||||
@@ -1880,7 +1967,7 @@ static int safeModeAuth(
|
||||
"zipfile",
|
||||
"zipfile_cds",
|
||||
};
|
||||
UNUSED_PARAMETER(zA2);
|
||||
UNUSED_PARAMETER(zA1);
|
||||
UNUSED_PARAMETER(zA3);
|
||||
UNUSED_PARAMETER(zA4);
|
||||
switch( op ){
|
||||
@@ -1895,7 +1982,7 @@ static int safeModeAuth(
|
||||
case SQLITE_FUNCTION: {
|
||||
int i;
|
||||
for(i=0; i<ArraySize(azProhibitedFunctions); i++){
|
||||
if( sqlite3_stricmp(zA1, azProhibitedFunctions[i])==0 ){
|
||||
if( sqlite3_stricmp(zA2, azProhibitedFunctions[i])==0 ){
|
||||
failIfSafeMode(p, "cannot use the %s() function in safe mode",
|
||||
azProhibitedFunctions[i]);
|
||||
}
|
||||
@@ -2082,7 +2169,7 @@ static void eqp_render_level(ShellState *p, int iEqpId){
|
||||
/*
|
||||
** Display and reset the EXPLAIN QUERY PLAN data
|
||||
*/
|
||||
static void eqp_render(ShellState *p){
|
||||
static void eqp_render(ShellState *p, i64 nCycle){
|
||||
EQPGraphRow *pRow = p->sGraph.pRow;
|
||||
if( pRow ){
|
||||
if( pRow->zText[0]=='-' ){
|
||||
@@ -2093,6 +2180,8 @@ static void eqp_render(ShellState *p){
|
||||
utf8_printf(p->out, "%s\n", pRow->zText+3);
|
||||
p->sGraph.pRow = pRow->pNext;
|
||||
sqlite3_free(pRow);
|
||||
}else if( nCycle>0 ){
|
||||
utf8_printf(p->out, "QUERY PLAN (cycles=%lld [100%%])\n", nCycle);
|
||||
}else{
|
||||
utf8_printf(p->out, "QUERY PLAN\n");
|
||||
}
|
||||
@@ -2970,6 +3059,35 @@ static int display_stats(
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
static int scanStatsHeight(sqlite3_stmt *p, int iEntry){
|
||||
int iPid = 0;
|
||||
int ret = 1;
|
||||
sqlite3_stmt_scanstatus_v2(p, iEntry,
|
||||
SQLITE_SCANSTAT_SELECTID, SQLITE_SCANSTAT_COMPLEX, (void*)&iPid
|
||||
);
|
||||
while( iPid!=0 ){
|
||||
int ii;
|
||||
for(ii=0; 1; ii++){
|
||||
int iId;
|
||||
int res;
|
||||
res = sqlite3_stmt_scanstatus_v2(p, ii,
|
||||
SQLITE_SCANSTAT_SELECTID, SQLITE_SCANSTAT_COMPLEX, (void*)&iId
|
||||
);
|
||||
if( res ) break;
|
||||
if( iId==iPid ){
|
||||
sqlite3_stmt_scanstatus_v2(p, ii,
|
||||
SQLITE_SCANSTAT_PARENTID, SQLITE_SCANSTAT_COMPLEX, (void*)&iPid
|
||||
);
|
||||
}
|
||||
}
|
||||
ret++;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
** Display scan stats.
|
||||
*/
|
||||
@@ -2981,40 +3099,70 @@ static void display_scanstats(
|
||||
UNUSED_PARAMETER(db);
|
||||
UNUSED_PARAMETER(pArg);
|
||||
#else
|
||||
int i, k, n, mx;
|
||||
raw_printf(pArg->out, "-------- scanstats --------\n");
|
||||
mx = 0;
|
||||
for(k=0; k<=mx; k++){
|
||||
double rEstLoop = 1.0;
|
||||
for(i=n=0; 1; i++){
|
||||
sqlite3_stmt *p = pArg->pStmt;
|
||||
sqlite3_int64 nLoop, nVisit;
|
||||
double rEst;
|
||||
int iSid;
|
||||
const char *zExplain;
|
||||
if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
|
||||
break;
|
||||
static const int f = SQLITE_SCANSTAT_COMPLEX;
|
||||
sqlite3_stmt *p = pArg->pStmt;
|
||||
int ii = 0;
|
||||
i64 nTotal = 0;
|
||||
int nWidth = 0;
|
||||
eqp_reset(pArg);
|
||||
|
||||
for(ii=0; 1; ii++){
|
||||
const char *z = 0;
|
||||
int n = 0;
|
||||
if( sqlite3_stmt_scanstatus_v2(p,ii,SQLITE_SCANSTAT_EXPLAIN,f,(void*)&z) ){
|
||||
break;
|
||||
}
|
||||
n = strlen(z) + scanStatsHeight(p, ii)*3;
|
||||
if( n>nWidth ) nWidth = n;
|
||||
}
|
||||
nWidth += 4;
|
||||
|
||||
sqlite3_stmt_scanstatus_v2(p, -1, SQLITE_SCANSTAT_NCYCLE, f, (void*)&nTotal);
|
||||
for(ii=0; 1; ii++){
|
||||
i64 nLoop = 0;
|
||||
i64 nRow = 0;
|
||||
i64 nCycle = 0;
|
||||
int iId = 0;
|
||||
int iPid = 0;
|
||||
const char *z = 0;
|
||||
char *zText = 0;
|
||||
double rEst = 0.0;
|
||||
|
||||
if( sqlite3_stmt_scanstatus_v2(p,ii,SQLITE_SCANSTAT_EXPLAIN,f,(void*)&z) ){
|
||||
break;
|
||||
}
|
||||
sqlite3_stmt_scanstatus_v2(p, ii, SQLITE_SCANSTAT_EST,f,(void*)&rEst);
|
||||
sqlite3_stmt_scanstatus_v2(p, ii, SQLITE_SCANSTAT_NLOOP,f,(void*)&nLoop);
|
||||
sqlite3_stmt_scanstatus_v2(p, ii, SQLITE_SCANSTAT_NVISIT,f,(void*)&nRow);
|
||||
sqlite3_stmt_scanstatus_v2(p, ii, SQLITE_SCANSTAT_NCYCLE,f,(void*)&nCycle);
|
||||
sqlite3_stmt_scanstatus_v2(p, ii, SQLITE_SCANSTAT_SELECTID,f,(void*)&iId);
|
||||
sqlite3_stmt_scanstatus_v2(p, ii, SQLITE_SCANSTAT_PARENTID,f,(void*)&iPid);
|
||||
|
||||
zText = sqlite3_mprintf("%s", z);
|
||||
if( nCycle>=0 || nLoop>=0 || nRow>=0 ){
|
||||
char *z = 0;
|
||||
if( nCycle>=0 && nTotal>0 ){
|
||||
z = sqlite3_mprintf("%zcycles=%lld [%d%%]", z,
|
||||
nCycle, ((nCycle*100)+nTotal/2) / nTotal
|
||||
);
|
||||
}
|
||||
sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
|
||||
if( iSid>mx ) mx = iSid;
|
||||
if( iSid!=k ) continue;
|
||||
if( n==0 ){
|
||||
rEstLoop = (double)nLoop;
|
||||
if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
|
||||
if( nLoop>=0 ){
|
||||
z = sqlite3_mprintf("%z%sloops=%lld", z, z ? " " : "", nLoop);
|
||||
}
|
||||
n++;
|
||||
sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
|
||||
sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
|
||||
sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
|
||||
utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
|
||||
rEstLoop *= rEst;
|
||||
raw_printf(pArg->out,
|
||||
" nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
|
||||
nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
|
||||
if( nRow>=0 ){
|
||||
z = sqlite3_mprintf("%z%srows=%lld", z, z ? " " : "", nRow);
|
||||
}
|
||||
|
||||
zText = sqlite3_mprintf(
|
||||
"% *z (%z)", -1*(nWidth-scanStatsHeight(p, ii)*3), zText, z
|
||||
);
|
||||
}
|
||||
|
||||
eqp_append(pArg, iId, iPid, zText);
|
||||
sqlite3_free(zText);
|
||||
}
|
||||
raw_printf(pArg->out, "---------------------------\n");
|
||||
|
||||
eqp_render(pArg, nTotal);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -3938,10 +4086,10 @@ static int shell_exec(
|
||||
int iEqpId = sqlite3_column_int(pExplain, 0);
|
||||
int iParentId = sqlite3_column_int(pExplain, 1);
|
||||
if( zEQPLine==0 ) zEQPLine = "";
|
||||
if( zEQPLine[0]=='-' ) eqp_render(pArg);
|
||||
if( zEQPLine[0]=='-' ) eqp_render(pArg, 0);
|
||||
eqp_append(pArg, iEqpId, iParentId, zEQPLine);
|
||||
}
|
||||
eqp_render(pArg);
|
||||
eqp_render(pArg, 0);
|
||||
}
|
||||
sqlite3_finalize(pExplain);
|
||||
sqlite3_free(zEQP);
|
||||
@@ -3990,7 +4138,7 @@ static int shell_exec(
|
||||
bind_prepared_stmt(pArg, pStmt);
|
||||
exec_prepared_stmt(pArg, pStmt);
|
||||
explain_data_delete(pArg);
|
||||
eqp_render(pArg);
|
||||
eqp_render(pArg, 0);
|
||||
|
||||
/* print usage stats if stats on */
|
||||
if( pArg && pArg->statsOn ){
|
||||
@@ -10210,7 +10358,7 @@ static int do_meta_command(char *zLine, ShellState *p){
|
||||
if( zLike ) sqlite3_bind_text(pStmt,1,zLike,-1,SQLITE_STATIC);
|
||||
lrc = SQLITE_ROW==sqlite3_step(pStmt);
|
||||
if( lrc ){
|
||||
const char *zGenQuery = sqlite3_column_text(pStmt,0);
|
||||
const char *zGenQuery = (char*)sqlite3_column_text(pStmt,0);
|
||||
sqlite3_stmt *pCheckStmt;
|
||||
lrc = sqlite3_prepare_v2(p->db, zGenQuery, -1, &pCheckStmt, 0);
|
||||
if( bDebug ) utf8_printf(p->out, "%s\n", zGenQuery);
|
||||
@@ -10957,7 +11105,8 @@ typedef enum {
|
||||
** The scan is resumable for subsequent lines when prior
|
||||
** return values are passed as the 2nd argument.
|
||||
*/
|
||||
static QuickScanState quickscan(char *zLine, QuickScanState qss){
|
||||
static QuickScanState quickscan(char *zLine, QuickScanState qss,
|
||||
SCAN_TRACKER_REFTYPE pst){
|
||||
char cin;
|
||||
char cWait = (char)qss; /* intentional narrowing loss */
|
||||
if( cWait==0 ){
|
||||
@@ -10981,6 +11130,7 @@ static QuickScanState quickscan(char *zLine, QuickScanState qss){
|
||||
if( *zLine=='*' ){
|
||||
++zLine;
|
||||
cWait = '*';
|
||||
CONTINUE_PROMPT_AWAITS(pst, "/*");
|
||||
qss = QSS_SETV(qss, cWait);
|
||||
goto TermScan;
|
||||
}
|
||||
@@ -10991,7 +11141,14 @@ static QuickScanState quickscan(char *zLine, QuickScanState qss){
|
||||
case '`': case '\'': case '"':
|
||||
cWait = cin;
|
||||
qss = QSS_HasDark | cWait;
|
||||
CONTINUE_PROMPT_AWAITC(pst, cin);
|
||||
goto TermScan;
|
||||
case '(':
|
||||
CONTINUE_PAREN_INCR(pst, 1);
|
||||
break;
|
||||
case ')':
|
||||
CONTINUE_PAREN_INCR(pst, -1);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@@ -11007,6 +11164,7 @@ static QuickScanState quickscan(char *zLine, QuickScanState qss){
|
||||
continue;
|
||||
++zLine;
|
||||
cWait = 0;
|
||||
CONTINUE_PROMPT_AWAITC(pst, 0);
|
||||
qss = QSS_SETV(qss, 0);
|
||||
goto PlainScan;
|
||||
case '`': case '\'': case '"':
|
||||
@@ -11018,6 +11176,7 @@ static QuickScanState quickscan(char *zLine, QuickScanState qss){
|
||||
/* fall thru */
|
||||
case ']':
|
||||
cWait = 0;
|
||||
CONTINUE_PROMPT_AWAITC(pst, 0);
|
||||
qss = QSS_SETV(qss, 0);
|
||||
goto PlainScan;
|
||||
default: assert(0);
|
||||
@@ -11041,7 +11200,7 @@ static int line_is_command_terminator(char *zLine){
|
||||
zLine += 2; /* SQL Server */
|
||||
else
|
||||
return 0;
|
||||
return quickscan(zLine, QSS_Start)==QSS_Start;
|
||||
return quickscan(zLine, QSS_Start, 0)==QSS_Start;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -11181,6 +11340,7 @@ static int process_input(ShellState *p){
|
||||
}
|
||||
++p->inputNesting;
|
||||
p->lineno = 0;
|
||||
CONTINUE_PROMPT_RESET;
|
||||
while( errCnt==0 || !bail_on_error || (p->in==0 && stdin_is_interactive) ){
|
||||
fflush(p->out);
|
||||
zLine = one_input_line(p->in, zLine, nSql>0);
|
||||
@@ -11199,7 +11359,7 @@ static int process_input(ShellState *p){
|
||||
&& line_is_complete(zSql, nSql) ){
|
||||
memcpy(zLine,";",2);
|
||||
}
|
||||
qss = quickscan(zLine, qss);
|
||||
qss = quickscan(zLine, qss, CONTINUE_PROMPT_PSTATE);
|
||||
if( QSS_PLAINWHITE(qss) && nSql==0 ){
|
||||
/* Just swallow single-line whitespace */
|
||||
echo_group_input(p, zLine);
|
||||
@@ -11207,6 +11367,7 @@ static int process_input(ShellState *p){
|
||||
continue;
|
||||
}
|
||||
if( zLine && (zLine[0]=='.' || zLine[0]=='#') && nSql==0 ){
|
||||
CONTINUE_PROMPT_RESET;
|
||||
echo_group_input(p, zLine);
|
||||
if( zLine[0]=='.' ){
|
||||
rc = do_meta_command(zLine, p);
|
||||
@@ -11242,6 +11403,7 @@ static int process_input(ShellState *p){
|
||||
if( nSql && QSS_SEMITERM(qss) && sqlite3_complete(zSql) ){
|
||||
echo_group_input(p, zSql);
|
||||
errCnt += runOneSqlLine(p, zSql, p->in, startline);
|
||||
CONTINUE_PROMPT_RESET;
|
||||
nSql = 0;
|
||||
if( p->outCount ){
|
||||
output_reset(p);
|
||||
@@ -11261,6 +11423,7 @@ static int process_input(ShellState *p){
|
||||
/* This may be incomplete. Let the SQL parser deal with that. */
|
||||
echo_group_input(p, zSql);
|
||||
errCnt += runOneSqlLine(p, zSql, p->in, startline);
|
||||
CONTINUE_PROMPT_RESET;
|
||||
}
|
||||
free(zSql);
|
||||
free(zLine);
|
||||
|
||||
+57
-39
@@ -7014,15 +7014,6 @@ int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void));
|
||||
*/
|
||||
void sqlite3_reset_auto_extension(void);
|
||||
|
||||
/*
|
||||
** The interface to the virtual-table mechanism is currently considered
|
||||
** to be experimental. The interface might change in incompatible ways.
|
||||
** If this is a problem for you, do not use the interface at this time.
|
||||
**
|
||||
** When the virtual-table mechanism stabilizes, we will declare the
|
||||
** interface fixed, support it indefinitely, and remove this comment.
|
||||
*/
|
||||
|
||||
/*
|
||||
** Structures used by the virtual table interface
|
||||
*/
|
||||
@@ -7264,7 +7255,7 @@ struct sqlite3_index_info {
|
||||
** the [sqlite3_vtab_collation()] interface. For most real-world virtual
|
||||
** tables, the collating sequence of constraints does not matter (for example
|
||||
** because the constraints are numeric) and so the sqlite3_vtab_collation()
|
||||
** interface is no commonly needed.
|
||||
** interface is not commonly needed.
|
||||
*/
|
||||
#define SQLITE_INDEX_CONSTRAINT_EQ 2
|
||||
#define SQLITE_INDEX_CONSTRAINT_GT 4
|
||||
@@ -7423,16 +7414,6 @@ int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
|
||||
*/
|
||||
int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
|
||||
|
||||
/*
|
||||
** The interface to the virtual-table mechanism defined above (back up
|
||||
** to a comment remarkably similar to this one) is currently considered
|
||||
** to be experimental. The interface might change in incompatible ways.
|
||||
** If this is a problem for you, do not use the interface at this time.
|
||||
**
|
||||
** When the virtual-table mechanism stabilizes, we will declare the
|
||||
** interface fixed, support it indefinitely, and remove this comment.
|
||||
*/
|
||||
|
||||
/*
|
||||
** CAPI3REF: A Handle To An Open BLOB
|
||||
** KEYWORDS: {BLOB handle} {BLOB handles}
|
||||
@@ -9636,7 +9617,7 @@ int sqlite3_vtab_nochange(sqlite3_context*);
|
||||
** <li><p> Otherwise, "BINARY" is returned.
|
||||
** </ol>
|
||||
*/
|
||||
SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int);
|
||||
const char *sqlite3_vtab_collation(sqlite3_index_info*,int);
|
||||
|
||||
/*
|
||||
** CAPI3REF: Determine if a virtual table query is DISTINCT
|
||||
@@ -9905,6 +9886,10 @@ int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);
|
||||
** managed by the prepared statement S and will be automatically freed when
|
||||
** S is finalized.
|
||||
**
|
||||
** Not all values are available for all query elements. When a value is
|
||||
** not available, the output variable is set to -1 if the value is numeric,
|
||||
** or to NULL if it is a string (SQLITE_SCANSTAT_NAME).
|
||||
**
|
||||
** <dl>
|
||||
** [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>
|
||||
** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be
|
||||
@@ -9932,13 +9917,25 @@ int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);
|
||||
** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]
|
||||
** description for the X-th loop.
|
||||
**
|
||||
** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECT</dt>
|
||||
** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECTID</dt>
|
||||
** <dd>^The "int" variable pointed to by the V parameter will be set to the
|
||||
** "select-id" for the X-th loop. The select-id identifies which query or
|
||||
** subquery the loop is part of. The main query has a select-id of zero.
|
||||
** The select-id is the same value as is output in the first column
|
||||
** of an [EXPLAIN QUERY PLAN] query.
|
||||
** id for the X-th query plan element. The id value is unique within the
|
||||
** statement. The select-id is the same value as is output in the first
|
||||
** column of an [EXPLAIN QUERY PLAN] query.
|
||||
** </dl>
|
||||
**
|
||||
** [[SQLITE_SCANSTAT_PARENTID]] <dt>SQLITE_SCANSTAT_PARENTID</dt>
|
||||
** <dd>The "int" variable pointed to by the V parameter will be set to the
|
||||
** the id of the parent of the current query element, if applicable, or
|
||||
** to zero if the query element has no parent. This is the same value as
|
||||
** returned in the second column of an [EXPLAIN QUERY PLAN] query.
|
||||
**
|
||||
** [[SQLITE_SCANSTAT_NCYCLE]] <dt>SQLITE_SCANSTAT_NCYCLE</dt>
|
||||
** <dd>The sqlite3_int64 output value is set to the number of cycles,
|
||||
** according to the processor time-stamp counter, that elapsed while the
|
||||
** query element was being processed. This value is not available for
|
||||
** all query elements - if it is unavailable the output variable is
|
||||
** set to -1.
|
||||
*/
|
||||
#define SQLITE_SCANSTAT_NLOOP 0
|
||||
#define SQLITE_SCANSTAT_NVISIT 1
|
||||
@@ -9946,12 +9943,14 @@ int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);
|
||||
#define SQLITE_SCANSTAT_NAME 3
|
||||
#define SQLITE_SCANSTAT_EXPLAIN 4
|
||||
#define SQLITE_SCANSTAT_SELECTID 5
|
||||
#define SQLITE_SCANSTAT_PARENTID 6
|
||||
#define SQLITE_SCANSTAT_NCYCLE 7
|
||||
|
||||
/*
|
||||
** CAPI3REF: Prepared Statement Scan Status
|
||||
** METHOD: sqlite3_stmt
|
||||
**
|
||||
** This interface returns information about the predicted and measured
|
||||
** These interfaces return information about the predicted and measured
|
||||
** performance for pStmt. Advanced applications can use this
|
||||
** interface to compare the predicted and the measured performance and
|
||||
** issue warnings and/or rerun [ANALYZE] if discrepancies are found.
|
||||
@@ -9962,19 +9961,25 @@ int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);
|
||||
**
|
||||
** The "iScanStatusOp" parameter determines which status information to return.
|
||||
** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior
|
||||
** of this interface is undefined.
|
||||
** ^The requested measurement is written into a variable pointed to by
|
||||
** the "pOut" parameter.
|
||||
** Parameter "idx" identifies the specific loop to retrieve statistics for.
|
||||
** Loops are numbered starting from zero. ^If idx is out of range - less than
|
||||
** zero or greater than or equal to the total number of loops used to implement
|
||||
** the statement - a non-zero value is returned and the variable that pOut
|
||||
** points to is unchanged.
|
||||
** of this interface is undefined. ^The requested measurement is written into
|
||||
** a variable pointed to by the "pOut" parameter.
|
||||
**
|
||||
** ^Statistics might not be available for all loops in all statements. ^In cases
|
||||
** where there exist loops with no available statistics, this function behaves
|
||||
** as if the loop did not exist - it returns non-zero and leave the variable
|
||||
** that pOut points to unchanged.
|
||||
** The "flags" parameter must be passed a mask of flags. At present only
|
||||
** one flag is defined - SQLITE_SCANSTAT_COMPLEX. If SQLITE_SCANSTAT_COMPLEX
|
||||
** is specified, then status information is available for all elements
|
||||
** of a query plan that are reported by "EXPLAIN QUERY PLAN" output. If
|
||||
** SQLITE_SCANSTAT_COMPLEX is not specified, then only query plan elements
|
||||
** that correspond to query loops (the "SCAN..." and "SEARCH..." elements of
|
||||
** the EXPLAIN QUERY PLAN output) are available. Invoking API
|
||||
** sqlite3_stmt_scanstatus() is equivalent to calling
|
||||
** sqlite3_stmt_scanstatus_v2() with a zeroed flags parameter.
|
||||
**
|
||||
** Parameter "idx" identifies the specific query element to retrieve statistics
|
||||
** for. Query elements are numbered starting from zero. A value of -1 may be
|
||||
** to query for statistics regarding the entire query. ^If idx is out of range
|
||||
** - less than -1 or greater than or equal to the total number of query
|
||||
** elements used to implement the statement - a non-zero value is returned and
|
||||
** the variable that pOut points to is unchanged.
|
||||
**
|
||||
** See also: [sqlite3_stmt_scanstatus_reset()]
|
||||
*/
|
||||
@@ -9984,6 +9989,19 @@ int sqlite3_stmt_scanstatus(
|
||||
int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */
|
||||
void *pOut /* Result written here */
|
||||
);
|
||||
int sqlite3_stmt_scanstatus_v2(
|
||||
sqlite3_stmt *pStmt, /* Prepared statement for which info desired */
|
||||
int idx, /* Index of loop to report on */
|
||||
int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */
|
||||
int flags, /* Mask of flags defined below */
|
||||
void *pOut /* Result written here */
|
||||
);
|
||||
|
||||
/*
|
||||
** CAPI3REF: Prepared Statement Scan Status
|
||||
** KEYWORDS: {scan status flags}
|
||||
*/
|
||||
#define SQLITE_SCANSTAT_COMPLEX 0x0001
|
||||
|
||||
/*
|
||||
** CAPI3REF: Zero Scan-Status Counters
|
||||
|
||||
+3
-1
@@ -5565,7 +5565,9 @@ const char **sqlite3CompileOptions(int *pnOpt);
|
||||
int sqlite3KvvfsInit(void);
|
||||
#endif
|
||||
|
||||
#if defined(VDBE_PROFILE) || defined(SQLITE_PERFORMANCE_TRACE)
|
||||
#if defined(VDBE_PROFILE) \
|
||||
|| defined(SQLITE_PERFORMANCE_TRACE) \
|
||||
|| defined(SQLITE_ENABLE_STMT_SCANSTATUS)
|
||||
sqlite3_uint64 sqlite3Hwtime(void);
|
||||
#endif
|
||||
|
||||
|
||||
+85
-22
@@ -2188,7 +2188,7 @@ static int SQLITE_TCLAPI test_stmt_status(
|
||||
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
/*
|
||||
** Usage: sqlite3_stmt_scanstatus STMT IDX
|
||||
** Usage: sqlite3_stmt_scanstatus ?-flags FLAGS? STMT IDX
|
||||
*/
|
||||
static int SQLITE_TCLAPI test_stmt_scanstatus(
|
||||
void * clientData,
|
||||
@@ -2203,36 +2203,99 @@ static int SQLITE_TCLAPI test_stmt_scanstatus(
|
||||
const char *zExplain;
|
||||
sqlite3_int64 nLoop;
|
||||
sqlite3_int64 nVisit;
|
||||
sqlite3_int64 nCycle;
|
||||
double rEst;
|
||||
int res;
|
||||
int flags = 0;
|
||||
int iSelectId = 0;
|
||||
int iParentId = 0;
|
||||
|
||||
if( objc!=3 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "STMT IDX");
|
||||
if( objc==5 ){
|
||||
struct Flag {
|
||||
const char *zFlag;
|
||||
int flag;
|
||||
} aTbl[] = {
|
||||
{"complex", SQLITE_SCANSTAT_COMPLEX},
|
||||
{0, 0}
|
||||
};
|
||||
|
||||
Tcl_Obj **aFlag = 0;
|
||||
int nFlag = 0;
|
||||
int ii;
|
||||
|
||||
if( Tcl_ListObjGetElements(interp, objv[2], &nFlag, &aFlag) ){
|
||||
return TCL_ERROR;
|
||||
}
|
||||
for(ii=0; ii<nFlag; ii++){
|
||||
int iVal = 0;
|
||||
int res = Tcl_GetIndexFromObjStruct(
|
||||
interp, aFlag[ii], aTbl, sizeof(aTbl[0]), "flag", 0, &iVal
|
||||
);
|
||||
if( res ) return TCL_ERROR;
|
||||
flags |= aTbl[iVal].flag;
|
||||
}
|
||||
}
|
||||
|
||||
if( objc!=3 && objc!=5 ){
|
||||
Tcl_WrongNumArgs(interp, 1, objv, "-flags FLAGS STMT IDX");
|
||||
return TCL_ERROR;
|
||||
}
|
||||
if( getStmtPointer(interp, Tcl_GetString(objv[objc-2]), &pStmt)
|
||||
|| Tcl_GetIntFromObj(interp, objv[objc-1], &idx)
|
||||
){
|
||||
return TCL_ERROR;
|
||||
}
|
||||
if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
|
||||
if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
|
||||
|
||||
res = sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop);
|
||||
if( res==0 ){
|
||||
if( idx<0 ){
|
||||
Tcl_Obj *pRet = Tcl_NewObj();
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nLoop", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nLoop));
|
||||
sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nVisit", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nVisit));
|
||||
sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_EST, (void*)&rEst);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nEst", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewDoubleObj(rEst));
|
||||
sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_NAME, (void*)&zName);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zName", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zName, -1));
|
||||
sqlite3_stmt_scanstatus(pStmt, idx, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zExplain", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zExplain, -1));
|
||||
res = sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, -1, SQLITE_SCANSTAT_NCYCLE, flags, (void*)&nCycle
|
||||
);
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_NCYCLE, flags, (void*)&nCycle);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nCycle", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nCycle));
|
||||
Tcl_SetObjResult(interp, pRet);
|
||||
}else{
|
||||
Tcl_ResetResult(interp);
|
||||
res = sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_NLOOP, flags, (void*)&nLoop
|
||||
);
|
||||
if( res==0 ){
|
||||
Tcl_Obj *pRet = Tcl_NewObj();
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nLoop", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nLoop));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_NVISIT, flags, (void*)&nVisit);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nVisit", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nVisit));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_EST, flags, (void*)&rEst);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nEst", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewDoubleObj(rEst));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_NAME, flags, (void*)&zName);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zName", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zName, -1));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_EXPLAIN, flags, (void*)&zExplain);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("zExplain", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zExplain, -1));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_SELECTID, flags, (void*)&iSelectId);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("iSelectId", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iSelectId));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_PARENTID, flags, (void*)&iParentId);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("iParentId", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iParentId));
|
||||
sqlite3_stmt_scanstatus_v2(
|
||||
pStmt, idx, SQLITE_SCANSTAT_NCYCLE, flags, (void*)&nCycle);
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj("nCycle", -1));
|
||||
Tcl_ListObjAppendElement(0, pRet, Tcl_NewWideIntObj(nCycle));
|
||||
Tcl_SetObjResult(interp, pRet);
|
||||
}else{
|
||||
Tcl_ResetResult(interp);
|
||||
}
|
||||
}
|
||||
return TCL_OK;
|
||||
}
|
||||
|
||||
@@ -461,7 +461,6 @@ static int demoDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
|
||||
|
||||
if( rc==0 && dirSync ){
|
||||
int dfd; /* File descriptor open on directory */
|
||||
int i; /* Iterator variable */
|
||||
char *zSlash;
|
||||
char zDir[MAXPATHNAME+1]; /* Name of directory containing file zPath */
|
||||
|
||||
|
||||
+3
-1
@@ -1717,6 +1717,8 @@ int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
|
||||
/*
|
||||
** High-resolution hardware timer used for debugging and testing only.
|
||||
*/
|
||||
#if defined(VDBE_PROFILE) || defined(SQLITE_PERFORMANCE_TRACE)
|
||||
#if defined(VDBE_PROFILE) \
|
||||
|| defined(SQLITE_PERFORMANCE_TRACE) \
|
||||
|| defined(SQLITE_ENABLE_STMT_SCANSTATUS)
|
||||
# include "hwtime.h"
|
||||
#endif
|
||||
|
||||
+80
-57
@@ -617,7 +617,6 @@ void sqlite3VdbeRegisterDump(Vdbe *v){
|
||||
# define REGISTER_TRACE(R,M)
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef NDEBUG
|
||||
/*
|
||||
** This function is only called from within an assert() expression. It
|
||||
@@ -707,10 +706,8 @@ int sqlite3VdbeExec(
|
||||
){
|
||||
Op *aOp = p->aOp; /* Copy of p->aOp */
|
||||
Op *pOp = aOp; /* Current operation */
|
||||
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
|
||||
Op *pOrigOp; /* Value of pOp at the top of the loop */
|
||||
#endif
|
||||
#ifdef SQLITE_DEBUG
|
||||
Op *pOrigOp; /* Value of pOp at the top of the loop */
|
||||
int nExtraDelete = 0; /* Verifies FORDELETE and AUXDELETE flags */
|
||||
#endif
|
||||
int rc = SQLITE_OK; /* Value to return */
|
||||
@@ -727,8 +724,8 @@ int sqlite3VdbeExec(
|
||||
Mem *pIn2 = 0; /* 2nd input operand */
|
||||
Mem *pIn3 = 0; /* 3rd input operand */
|
||||
Mem *pOut = 0; /* Output operand */
|
||||
#ifdef VDBE_PROFILE
|
||||
u64 start; /* CPU clock count at start of opcode */
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
u64 *pnCycle = 0;
|
||||
#endif
|
||||
/*** INSERT STACK UNION HERE ***/
|
||||
|
||||
@@ -791,12 +788,17 @@ int sqlite3VdbeExec(
|
||||
assert( rc==SQLITE_OK );
|
||||
|
||||
assert( pOp>=aOp && pOp<&aOp[p->nOp]);
|
||||
#ifdef VDBE_PROFILE
|
||||
start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
|
||||
#endif
|
||||
nVmStep++;
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
if( p->anExec ){
|
||||
assert( p->anExec && p->anCycle );
|
||||
p->anExec[(int)(pOp-aOp)]++;
|
||||
pnCycle = &p->anCycle[pOp-aOp];
|
||||
# ifdef VDBE_PROFILE
|
||||
if( sqlite3NProfileCnt==0 )
|
||||
# endif
|
||||
*pnCycle -= sqlite3Hwtime();
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Only allow tracing if SQLITE_DEBUG is defined.
|
||||
@@ -858,7 +860,7 @@ int sqlite3VdbeExec(
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
|
||||
#ifdef SQLITE_DEBUG
|
||||
pOrigOp = pOp;
|
||||
#endif
|
||||
|
||||
@@ -2778,7 +2780,7 @@ case OP_Offset: { /* out3 */
|
||||
** typeof() function or the IS NULL or IS NOT NULL operators or the
|
||||
** equivalent. In this case, all content loading can be omitted.
|
||||
*/
|
||||
case OP_Column: {
|
||||
case OP_Column: { /* ncycle */
|
||||
u32 p2; /* column number to retrieve */
|
||||
VdbeCursor *pC; /* The VDBE cursor */
|
||||
BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */
|
||||
@@ -4130,7 +4132,7 @@ case OP_SetCookie: {
|
||||
**
|
||||
** See also: OP_OpenRead, OP_ReopenIdx
|
||||
*/
|
||||
case OP_ReopenIdx: {
|
||||
case OP_ReopenIdx: { /* ncycle */
|
||||
int nField;
|
||||
KeyInfo *pKeyInfo;
|
||||
u32 p2;
|
||||
@@ -4151,7 +4153,7 @@ case OP_ReopenIdx: {
|
||||
}
|
||||
/* If the cursor is not currently open or is open on a different
|
||||
** index, then fall through into OP_OpenRead to force a reopen */
|
||||
case OP_OpenRead:
|
||||
case OP_OpenRead: /* ncycle */
|
||||
case OP_OpenWrite:
|
||||
|
||||
assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
|
||||
@@ -4245,7 +4247,7 @@ open_cursor_set_hints:
|
||||
**
|
||||
** Duplicate ephemeral cursors are used for self-joins of materialized views.
|
||||
*/
|
||||
case OP_OpenDup: {
|
||||
case OP_OpenDup: { /* ncycle */
|
||||
VdbeCursor *pOrig; /* The original cursor to be duplicated */
|
||||
VdbeCursor *pCx; /* The new cursor */
|
||||
|
||||
@@ -4307,8 +4309,8 @@ case OP_OpenDup: {
|
||||
** by this opcode will be used for automatically created transient
|
||||
** indices in joins.
|
||||
*/
|
||||
case OP_OpenAutoindex:
|
||||
case OP_OpenEphemeral: {
|
||||
case OP_OpenAutoindex: /* ncycle */
|
||||
case OP_OpenEphemeral: { /* ncycle */
|
||||
VdbeCursor *pCx;
|
||||
KeyInfo *pKeyInfo;
|
||||
|
||||
@@ -4466,7 +4468,7 @@ case OP_OpenPseudo: {
|
||||
** Close a cursor previously opened as P1. If P1 is not
|
||||
** currently open, this instruction is a no-op.
|
||||
*/
|
||||
case OP_Close: {
|
||||
case OP_Close: { /* ncycle */
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
|
||||
p->apCsr[pOp->p1] = 0;
|
||||
@@ -4583,10 +4585,10 @@ case OP_ColumnsUsed: {
|
||||
**
|
||||
** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
|
||||
*/
|
||||
case OP_SeekLT: /* jump, in3, group */
|
||||
case OP_SeekLE: /* jump, in3, group */
|
||||
case OP_SeekGE: /* jump, in3, group */
|
||||
case OP_SeekGT: { /* jump, in3, group */
|
||||
case OP_SeekLT: /* jump, in3, group, ncycle */
|
||||
case OP_SeekLE: /* jump, in3, group, ncycle */
|
||||
case OP_SeekGE: /* jump, in3, group, ncycle */
|
||||
case OP_SeekGT: { /* jump, in3, group, ncycle */
|
||||
int res; /* Comparison result */
|
||||
int oc; /* Opcode */
|
||||
VdbeCursor *pC; /* The cursor to seek */
|
||||
@@ -4852,7 +4854,7 @@ seek_not_found:
|
||||
** jump to SeekOP.P2 if This.P5==0 or to This.P2 if This.P5>0.
|
||||
** </ol>
|
||||
*/
|
||||
case OP_SeekScan: {
|
||||
case OP_SeekScan: { /* ncycle */
|
||||
VdbeCursor *pC;
|
||||
int res;
|
||||
int nStep;
|
||||
@@ -4974,7 +4976,7 @@ case OP_SeekScan: {
|
||||
**
|
||||
** P1 must be a valid b-tree cursor.
|
||||
*/
|
||||
case OP_SeekHit: {
|
||||
case OP_SeekHit: { /* ncycle */
|
||||
VdbeCursor *pC;
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
pC = p->apCsr[pOp->p1];
|
||||
@@ -5106,7 +5108,7 @@ case OP_IfNotOpen: { /* jump */
|
||||
**
|
||||
** See also: NotFound, Found, NotExists
|
||||
*/
|
||||
case OP_IfNoHope: { /* jump, in3 */
|
||||
case OP_IfNoHope: { /* jump, in3, ncycle */
|
||||
VdbeCursor *pC;
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
pC = p->apCsr[pOp->p1];
|
||||
@@ -5120,9 +5122,9 @@ case OP_IfNoHope: { /* jump, in3 */
|
||||
/* Fall through into OP_NotFound */
|
||||
/* no break */ deliberate_fall_through
|
||||
}
|
||||
case OP_NoConflict: /* jump, in3 */
|
||||
case OP_NotFound: /* jump, in3 */
|
||||
case OP_Found: { /* jump, in3 */
|
||||
case OP_NoConflict: /* jump, in3, ncycle */
|
||||
case OP_NotFound: /* jump, in3, ncycle */
|
||||
case OP_Found: { /* jump, in3, ncycle */
|
||||
int alreadyExists;
|
||||
int ii;
|
||||
VdbeCursor *pC;
|
||||
@@ -5252,7 +5254,7 @@ case OP_Found: { /* jump, in3 */
|
||||
**
|
||||
** See also: Found, NotFound, NoConflict, SeekRowid
|
||||
*/
|
||||
case OP_SeekRowid: { /* jump, in3 */
|
||||
case OP_SeekRowid: { /* jump, in3, ncycle */
|
||||
VdbeCursor *pC;
|
||||
BtCursor *pCrsr;
|
||||
int res;
|
||||
@@ -5277,7 +5279,7 @@ case OP_SeekRowid: { /* jump, in3 */
|
||||
}
|
||||
/* Fall through into OP_NotExists */
|
||||
/* no break */ deliberate_fall_through
|
||||
case OP_NotExists: /* jump, in3 */
|
||||
case OP_NotExists: /* jump, in3, ncycle */
|
||||
pIn3 = &aMem[pOp->p3];
|
||||
assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
@@ -5901,7 +5903,7 @@ case OP_RowData: {
|
||||
** be a separate OP_VRowid opcode for use with virtual tables, but this
|
||||
** one opcode now works for both table types.
|
||||
*/
|
||||
case OP_Rowid: { /* out2 */
|
||||
case OP_Rowid: { /* out2, ncycle */
|
||||
VdbeCursor *pC;
|
||||
i64 v;
|
||||
sqlite3_vtab *pVtab;
|
||||
@@ -6000,8 +6002,8 @@ case OP_NullRow: {
|
||||
** from the end toward the beginning. In other words, the cursor is
|
||||
** configured to use Prev, not Next.
|
||||
*/
|
||||
case OP_SeekEnd:
|
||||
case OP_Last: { /* jump */
|
||||
case OP_SeekEnd: /* ncycle */
|
||||
case OP_Last: { /* jump, ncycle */
|
||||
VdbeCursor *pC;
|
||||
BtCursor *pCrsr;
|
||||
int res;
|
||||
@@ -6106,7 +6108,7 @@ case OP_Sort: { /* jump */
|
||||
** from the beginning toward the end. In other words, the cursor is
|
||||
** configured to use Next, not Prev.
|
||||
*/
|
||||
case OP_Rewind: { /* jump */
|
||||
case OP_Rewind: { /* jump, ncycle */
|
||||
VdbeCursor *pC;
|
||||
BtCursor *pCrsr;
|
||||
int res;
|
||||
@@ -6200,7 +6202,7 @@ case OP_SorterNext: { /* jump */
|
||||
rc = sqlite3VdbeSorterNext(db, pC);
|
||||
goto next_tail;
|
||||
|
||||
case OP_Prev: /* jump */
|
||||
case OP_Prev: /* jump, ncycle */
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
assert( pOp->p5==0
|
||||
|| pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
|
||||
@@ -6215,7 +6217,7 @@ case OP_Prev: /* jump */
|
||||
rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
|
||||
goto next_tail;
|
||||
|
||||
case OP_Next: /* jump */
|
||||
case OP_Next: /* jump, ncycle */
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
assert( pOp->p5==0
|
||||
|| pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP
|
||||
@@ -6407,8 +6409,8 @@ case OP_IdxDelete: {
|
||||
**
|
||||
** See also: Rowid, MakeRecord.
|
||||
*/
|
||||
case OP_DeferredSeek:
|
||||
case OP_IdxRowid: { /* out2 */
|
||||
case OP_DeferredSeek: /* ncycle */
|
||||
case OP_IdxRowid: { /* out2, ncycle */
|
||||
VdbeCursor *pC; /* The P1 index cursor */
|
||||
VdbeCursor *pTabCur; /* The P2 table cursor (OP_DeferredSeek only) */
|
||||
i64 rowid; /* Rowid that P1 current points to */
|
||||
@@ -6470,8 +6472,8 @@ case OP_IdxRowid: { /* out2 */
|
||||
** seek operation now, without further delay. If the cursor seek has
|
||||
** already occurred, this instruction is a no-op.
|
||||
*/
|
||||
case OP_FinishSeek: {
|
||||
VdbeCursor *pC; /* The P1 index cursor */
|
||||
case OP_FinishSeek: { /* ncycle */
|
||||
VdbeCursor *pC; /* The P1 index cursor */
|
||||
|
||||
assert( pOp->p1>=0 && pOp->p1<p->nCursor );
|
||||
pC = p->apCsr[pOp->p1];
|
||||
@@ -6526,10 +6528,10 @@ case OP_FinishSeek: {
|
||||
** If the P1 index entry is less than or equal to the key value then jump
|
||||
** to P2. Otherwise fall through to the next instruction.
|
||||
*/
|
||||
case OP_IdxLE: /* jump */
|
||||
case OP_IdxGT: /* jump */
|
||||
case OP_IdxLT: /* jump */
|
||||
case OP_IdxGE: { /* jump */
|
||||
case OP_IdxLE: /* jump, ncycle */
|
||||
case OP_IdxGT: /* jump, ncycle */
|
||||
case OP_IdxLT: /* jump, ncycle */
|
||||
case OP_IdxGE: { /* jump, ncycle */
|
||||
VdbeCursor *pC;
|
||||
int res;
|
||||
UnpackedRecord r;
|
||||
@@ -7150,8 +7152,9 @@ case OP_Program: { /* jump */
|
||||
pFrame->aOp = p->aOp;
|
||||
pFrame->nOp = p->nOp;
|
||||
pFrame->token = pProgram->token;
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
pFrame->anExec = p->anExec;
|
||||
pFrame->anCycle = p->anCycle;
|
||||
#endif
|
||||
#ifdef SQLITE_DEBUG
|
||||
pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;
|
||||
@@ -7189,8 +7192,9 @@ case OP_Program: { /* jump */
|
||||
memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
|
||||
p->aOp = aOp = pProgram->aOp;
|
||||
p->nOp = pProgram->nOp;
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
p->anExec = 0;
|
||||
p->anCycle = 0;
|
||||
#endif
|
||||
#ifdef SQLITE_DEBUG
|
||||
/* Verify that second and subsequent executions of the same trigger do not
|
||||
@@ -7948,7 +7952,7 @@ case OP_VDestroy: {
|
||||
** P1 is a cursor number. This opcode opens a cursor to the virtual
|
||||
** table and stores that cursor in P1.
|
||||
*/
|
||||
case OP_VOpen: {
|
||||
case OP_VOpen: { /* ncycle */
|
||||
VdbeCursor *pCur;
|
||||
sqlite3_vtab_cursor *pVCur;
|
||||
sqlite3_vtab *pVtab;
|
||||
@@ -7995,7 +7999,7 @@ case OP_VOpen: {
|
||||
** cursor. Register P3 is used to hold the values returned by
|
||||
** sqlite3_vtab_in_first() and sqlite3_vtab_in_next().
|
||||
*/
|
||||
case OP_VInitIn: { /* out2 */
|
||||
case OP_VInitIn: { /* out2, ncycle */
|
||||
VdbeCursor *pC; /* The cursor containing the RHS values */
|
||||
ValueList *pRhs; /* New ValueList object to put in reg[P2] */
|
||||
|
||||
@@ -8032,7 +8036,7 @@ case OP_VInitIn: { /* out2 */
|
||||
**
|
||||
** A jump is made to P2 if the result set after filtering would be empty.
|
||||
*/
|
||||
case OP_VFilter: { /* jump */
|
||||
case OP_VFilter: { /* jump, ncycle */
|
||||
int nArg;
|
||||
int iQuery;
|
||||
const sqlite3_module *pModule;
|
||||
@@ -8092,7 +8096,7 @@ case OP_VFilter: { /* jump */
|
||||
** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are
|
||||
** unused by OP_VColumn.
|
||||
*/
|
||||
case OP_VColumn: {
|
||||
case OP_VColumn: { /* ncycle */
|
||||
sqlite3_vtab *pVtab;
|
||||
const sqlite3_module *pModule;
|
||||
Mem *pDest;
|
||||
@@ -8144,7 +8148,7 @@ case OP_VColumn: {
|
||||
** jump to instruction P2. Or, if the virtual table has reached
|
||||
** the end of its result set, then fall through to the next instruction.
|
||||
*/
|
||||
case OP_VNext: { /* jump */
|
||||
case OP_VNext: { /* jump, ncycle */
|
||||
sqlite3_vtab *pVtab;
|
||||
const sqlite3_module *pModule;
|
||||
int res;
|
||||
@@ -8727,11 +8731,17 @@ default: { /* This is really OP_Noop, OP_Explain */
|
||||
*****************************************************************************/
|
||||
}
|
||||
|
||||
#ifdef VDBE_PROFILE
|
||||
{
|
||||
u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
|
||||
if( endTime>start ) pOrigOp->cycles += endTime - start;
|
||||
pOrigOp->cnt++;
|
||||
#if defined(VDBE_PROFILE)
|
||||
assert( pnCycle );
|
||||
if( pnCycle ){
|
||||
*pnCycle += sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
|
||||
assert( *pnCycle < (((u64)1) << 48) );
|
||||
pnCycle = 0;
|
||||
}
|
||||
#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS)
|
||||
if( pnCycle ){
|
||||
*pnCycle += sqlite3Hwtime();
|
||||
pnCycle = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -8808,6 +8818,19 @@ abort_due_to_error:
|
||||
** release the mutexes on btrees that were acquired at the
|
||||
** top. */
|
||||
vdbe_return:
|
||||
#if defined(VDBE_PROFILE)
|
||||
if( pnCycle ){
|
||||
*pnCycle += sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
|
||||
assert( *pnCycle < (((u64)1) << 48) );
|
||||
pnCycle = 0;
|
||||
}
|
||||
#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS)
|
||||
if( pnCycle ){
|
||||
*pnCycle += sqlite3Hwtime();
|
||||
pnCycle = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
|
||||
while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
|
||||
nProgressLimit += db->nProgressOps;
|
||||
|
||||
+12
-6
@@ -67,10 +67,6 @@ struct VdbeOp {
|
||||
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
|
||||
char *zComment; /* Comment to improve readability */
|
||||
#endif
|
||||
#ifdef VDBE_PROFILE
|
||||
u32 cnt; /* Number of times this instruction was executed */
|
||||
u64 cycles; /* Total time spent executing this instruction */
|
||||
#endif
|
||||
#ifdef SQLITE_VDBE_COVERAGE
|
||||
u32 iSrcLine; /* Source-code line that generated this opcode
|
||||
** with flags in the upper 8 bits */
|
||||
@@ -205,14 +201,20 @@ void sqlite3VdbeEndCoroutine(Vdbe*,int);
|
||||
#endif
|
||||
VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno);
|
||||
#ifndef SQLITE_OMIT_EXPLAIN
|
||||
void sqlite3VdbeExplain(Parse*,u8,const char*,...);
|
||||
int sqlite3VdbeExplain(Parse*,u8,const char*,...);
|
||||
void sqlite3VdbeExplainPop(Parse*);
|
||||
int sqlite3VdbeExplainParent(Parse*);
|
||||
# define ExplainQueryPlan(P) sqlite3VdbeExplain P
|
||||
# ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
# define ExplainQueryPlan2(V,P) (V = sqlite3VdbeExplain P)
|
||||
# else
|
||||
# define ExplainQueryPlan2(V,P) ExplainQueryPlan(P)
|
||||
# endif
|
||||
# define ExplainQueryPlanPop(P) sqlite3VdbeExplainPop(P)
|
||||
# define ExplainQueryPlanParent(P) sqlite3VdbeExplainParent(P)
|
||||
#else
|
||||
# define ExplainQueryPlan(P)
|
||||
# define ExplainQueryPlan2(V,P)
|
||||
# define ExplainQueryPlanPop(P)
|
||||
# define ExplainQueryPlanParent(P) 0
|
||||
# define sqlite3ExplainBreakpoint(A,B) /*no-op*/
|
||||
@@ -385,8 +387,12 @@ int sqlite3VdbeBytecodeVtabInit(sqlite3*);
|
||||
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const char*);
|
||||
void sqlite3VdbeScanStatusRange(Vdbe*, int, int, int);
|
||||
void sqlite3VdbeScanStatusCounters(Vdbe*, int, int, int);
|
||||
#else
|
||||
# define sqlite3VdbeScanStatus(a,b,c,d,e)
|
||||
# define sqlite3VdbeScanStatus(a,b,c,d,e,f)
|
||||
# define sqlite3VdbeScanStatusRange(a,b,c,d)
|
||||
# define sqlite3VdbeScanStatusCounters(a,b,c,d)
|
||||
#endif
|
||||
|
||||
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
|
||||
|
||||
+14
-1
@@ -172,6 +172,7 @@ struct VdbeFrame {
|
||||
VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */
|
||||
Op *aOp; /* Program instructions for parent frame */
|
||||
i64 *anExec; /* Event counters from parent frame */
|
||||
u64 *anCycle; /* Cycle counters from parent frame */
|
||||
Mem *aMem; /* Array of memory cells for parent frame */
|
||||
VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
|
||||
u8 *aOnce; /* Bitmask used by OP_Once */
|
||||
@@ -387,10 +388,19 @@ typedef unsigned bft; /* Bit Field Type */
|
||||
|
||||
/* The ScanStatus object holds a single value for the
|
||||
** sqlite3_stmt_scanstatus() interface.
|
||||
**
|
||||
** aAddrRange[]:
|
||||
** This array is used by ScanStatus elements associated with EQP
|
||||
** notes that make an SQLITE_SCANSTAT_NCYCLE value available. It is
|
||||
** an array of up to 3 ranges of VM addresses for which the Vdbe.anCycle[]
|
||||
** values should be summed to calculate the NCYCLE value. Each pair of
|
||||
** integer addresses is a start and end address (both inclusive) for a range
|
||||
** instructions. A start value of 0 indicates an empty range.
|
||||
*/
|
||||
typedef struct ScanStatus ScanStatus;
|
||||
struct ScanStatus {
|
||||
int addrExplain; /* OP_Explain for loop */
|
||||
int aAddrRange[6];
|
||||
int addrLoop; /* Address of "loops" counter */
|
||||
int addrVisit; /* Address of "rows visited" counter */
|
||||
int iSelectID; /* The "Select-ID" for this loop */
|
||||
@@ -482,8 +492,11 @@ struct Vdbe {
|
||||
u32 expmask; /* Binding to these vars invalidates VM */
|
||||
SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
|
||||
AuxData *pAuxData; /* Linked list of auxdata allocations */
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
i64 *anExec; /* Number of times each op has been executed */
|
||||
u64 *anCycle; /* Sum of sqlite3HwTime() spent in each opcode */
|
||||
#endif
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
int nScan; /* Entries in aScan[] */
|
||||
ScanStatus *aScan; /* Scan definitions for sqlite3_stmt_scanstatus() */
|
||||
#endif
|
||||
|
||||
+96
-6
@@ -15,6 +15,7 @@
|
||||
*/
|
||||
#include "sqliteInt.h"
|
||||
#include "vdbeInt.h"
|
||||
#include "opcodes.h"
|
||||
|
||||
#ifndef SQLITE_OMIT_DEPRECATED
|
||||
/*
|
||||
@@ -2111,23 +2112,60 @@ int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue){
|
||||
/*
|
||||
** Return status data for a single loop within query pStmt.
|
||||
*/
|
||||
int sqlite3_stmt_scanstatus(
|
||||
int sqlite3_stmt_scanstatus_v2(
|
||||
sqlite3_stmt *pStmt, /* Prepared statement being queried */
|
||||
int idx, /* Index of loop to report on */
|
||||
int iScan, /* Index of loop to report on */
|
||||
int iScanStatusOp, /* Which metric to return */
|
||||
int flags,
|
||||
void *pOut /* OUT: Write the answer here */
|
||||
){
|
||||
Vdbe *p = (Vdbe*)pStmt;
|
||||
ScanStatus *pScan;
|
||||
if( idx<0 || idx>=p->nScan ) return 1;
|
||||
pScan = &p->aScan[idx];
|
||||
int idx;
|
||||
|
||||
/* If the v2 flag is clear, then this function must ignore any ScanStatus
|
||||
** structures with ScanStatus.addrLoop set to 0. */
|
||||
if( iScan<0 ){
|
||||
int ii;
|
||||
if( iScanStatusOp==SQLITE_SCANSTAT_NCYCLE ){
|
||||
i64 res = 0;
|
||||
for(ii=0; ii<p->nOp; ii++){
|
||||
res += p->anCycle[ii];
|
||||
}
|
||||
*(i64*)pOut = res;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
if( flags & SQLITE_SCANSTAT_COMPLEX ){
|
||||
idx = iScan;
|
||||
pScan = &p->aScan[idx];
|
||||
}else{
|
||||
for(idx=0; idx<p->nScan; idx++){
|
||||
pScan = &p->aScan[idx];
|
||||
if( pScan->zName ){
|
||||
iScan--;
|
||||
if( iScan<0 ) break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if( idx>=p->nScan ) return 1;
|
||||
|
||||
switch( iScanStatusOp ){
|
||||
case SQLITE_SCANSTAT_NLOOP: {
|
||||
*(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop];
|
||||
if( pScan->addrLoop>0 ){
|
||||
*(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop];
|
||||
}else{
|
||||
*(sqlite3_int64*)pOut = -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SQLITE_SCANSTAT_NVISIT: {
|
||||
*(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit];
|
||||
if( pScan->addrVisit>0 ){
|
||||
*(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit];
|
||||
}else{
|
||||
*(sqlite3_int64*)pOut = -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SQLITE_SCANSTAT_EST: {
|
||||
@@ -2160,6 +2198,45 @@ int sqlite3_stmt_scanstatus(
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SQLITE_SCANSTAT_PARENTID: {
|
||||
if( pScan->addrExplain ){
|
||||
*(int*)pOut = p->aOp[ pScan->addrExplain ].p2;
|
||||
}else{
|
||||
*(int*)pOut = -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SQLITE_SCANSTAT_NCYCLE: {
|
||||
i64 res = 0;
|
||||
if( pScan->aAddrRange[0]==0 ){
|
||||
res = -1;
|
||||
}else{
|
||||
int ii;
|
||||
for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){
|
||||
int iIns = pScan->aAddrRange[ii];
|
||||
int iEnd = pScan->aAddrRange[ii+1];
|
||||
if( iIns==0 ) break;
|
||||
if( iIns>0 ){
|
||||
while( iIns<=iEnd ){
|
||||
res += p->anCycle[iIns];
|
||||
iIns++;
|
||||
}
|
||||
}else{
|
||||
int iOp;
|
||||
for(iOp=0; iOp<p->nOp; iOp++){
|
||||
Op *pOp = &p->aOp[iOp];
|
||||
if( pOp->p1!=iEnd ) continue;
|
||||
if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_NCYCLE)==0 ){
|
||||
continue;
|
||||
}
|
||||
res += p->anCycle[iOp];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
*(i64*)pOut = res;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
return 1;
|
||||
}
|
||||
@@ -2167,11 +2244,24 @@ int sqlite3_stmt_scanstatus(
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
** Return status data for a single loop within query pStmt.
|
||||
*/
|
||||
int sqlite3_stmt_scanstatus(
|
||||
sqlite3_stmt *pStmt, /* Prepared statement being queried */
|
||||
int iScan, /* Index of loop to report on */
|
||||
int iScanStatusOp, /* Which metric to return */
|
||||
void *pOut /* OUT: Write the answer here */
|
||||
){
|
||||
return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut);
|
||||
}
|
||||
|
||||
/*
|
||||
** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
|
||||
*/
|
||||
void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
|
||||
Vdbe *p = (Vdbe*)pStmt;
|
||||
memset(p->anExec, 0, p->nOp * sizeof(i64));
|
||||
memset(p->anCycle, 0, p->nOp * sizeof(u64));
|
||||
}
|
||||
#endif /* SQLITE_ENABLE_STMT_SCANSTATUS */
|
||||
|
||||
+79
-19
@@ -268,10 +268,6 @@ int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
|
||||
test_addop_breakpoint(i, &p->aOp[i]);
|
||||
}
|
||||
#endif
|
||||
#ifdef VDBE_PROFILE
|
||||
pOp->cycles = 0;
|
||||
pOp->cnt = 0;
|
||||
#endif
|
||||
#ifdef SQLITE_VDBE_COVERAGE
|
||||
pOp->iSrcLine = 0;
|
||||
#endif
|
||||
@@ -439,8 +435,9 @@ void sqlite3ExplainBreakpoint(const char *z1, const char *z2){
|
||||
** If the bPush flag is true, then make this opcode the parent for
|
||||
** subsequent Explains until sqlite3VdbeExplainPop() is called.
|
||||
*/
|
||||
void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
|
||||
#ifndef SQLITE_DEBUG
|
||||
int sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
|
||||
int addr = 0;
|
||||
#if !defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_STMT_SCANSTATUS)
|
||||
/* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
|
||||
** But omit them (for performance) during production builds */
|
||||
if( pParse->explain==2 )
|
||||
@@ -455,13 +452,15 @@ void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
|
||||
va_end(ap);
|
||||
v = pParse->pVdbe;
|
||||
iThis = v->nOp;
|
||||
sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
|
||||
addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
|
||||
zMsg, P4_DYNAMIC);
|
||||
sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetLastOp(v)->p4.z);
|
||||
if( bPush){
|
||||
pParse->addrExplain = iThis;
|
||||
}
|
||||
sqlite3VdbeScanStatus(v, iThis, 0, 0, 0, 0);
|
||||
}
|
||||
return addr;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1119,6 +1118,7 @@ void sqlite3VdbeScanStatus(
|
||||
aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
|
||||
if( aNew ){
|
||||
ScanStatus *pNew = &aNew[p->nScan++];
|
||||
memset(pNew, 0, sizeof(ScanStatus));
|
||||
pNew->addrExplain = addrExplain;
|
||||
pNew->addrLoop = addrLoop;
|
||||
pNew->addrVisit = addrVisit;
|
||||
@@ -1127,6 +1127,62 @@ void sqlite3VdbeScanStatus(
|
||||
p->aScan = aNew;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Add the range of instructions from addrStart to addrEnd (inclusive) to
|
||||
** the set of those corresponding to the sqlite3_stmt_scanstatus() counters
|
||||
** associated with the OP_Explain instruction at addrExplain. The
|
||||
** sum of the sqlite3Hwtime() values for each of these instructions
|
||||
** will be returned for SQLITE_SCANSTAT_NCYCLE requests.
|
||||
*/
|
||||
void sqlite3VdbeScanStatusRange(
|
||||
Vdbe *p,
|
||||
int addrExplain,
|
||||
int addrStart,
|
||||
int addrEnd
|
||||
){
|
||||
ScanStatus *pScan = 0;
|
||||
int ii;
|
||||
for(ii=p->nScan-1; ii>=0; ii--){
|
||||
pScan = &p->aScan[ii];
|
||||
if( pScan->addrExplain==addrExplain ) break;
|
||||
pScan = 0;
|
||||
}
|
||||
if( pScan ){
|
||||
if( addrEnd<0 ) addrEnd = sqlite3VdbeCurrentAddr(p)-1;
|
||||
for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){
|
||||
if( pScan->aAddrRange[ii]==0 ){
|
||||
pScan->aAddrRange[ii] = addrStart;
|
||||
pScan->aAddrRange[ii+1] = addrEnd;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Set the addresses for the SQLITE_SCANSTAT_NLOOP and SQLITE_SCANSTAT_NROW
|
||||
** counters for the query element associated with the OP_Explain at
|
||||
** addrExplain.
|
||||
*/
|
||||
void sqlite3VdbeScanStatusCounters(
|
||||
Vdbe *p,
|
||||
int addrExplain,
|
||||
int addrLoop,
|
||||
int addrVisit
|
||||
){
|
||||
ScanStatus *pScan = 0;
|
||||
int ii;
|
||||
for(ii=p->nScan-1; ii>=0; ii--){
|
||||
pScan = &p->aScan[ii];
|
||||
if( pScan->addrExplain==addrExplain ) break;
|
||||
pScan = 0;
|
||||
}
|
||||
if( pScan ){
|
||||
pScan->addrLoop = addrLoop;
|
||||
pScan->addrVisit = addrVisit;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@@ -2424,7 +2480,7 @@ static void *allocSpace(
|
||||
** running it.
|
||||
*/
|
||||
void sqlite3VdbeRewind(Vdbe *p){
|
||||
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
|
||||
#if defined(SQLITE_DEBUG)
|
||||
int i;
|
||||
#endif
|
||||
assert( p!=0 );
|
||||
@@ -2452,10 +2508,8 @@ void sqlite3VdbeRewind(Vdbe *p){
|
||||
p->iStatement = 0;
|
||||
p->nFkConstraint = 0;
|
||||
#ifdef VDBE_PROFILE
|
||||
for(i=0; i<p->nOp; i++){
|
||||
p->aOp[i].cnt = 0;
|
||||
p->aOp[i].cycles = 0;
|
||||
}
|
||||
memset(p->anExec, 0, sizeof(i64)*p->nOp);
|
||||
memset(p->anCycle, 0, sizeof(u64)*p->nOp);
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -2563,8 +2617,9 @@ void sqlite3VdbeMakeReady(
|
||||
p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));
|
||||
p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));
|
||||
p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64));
|
||||
p->anCycle = allocSpace(&x, 0, p->nOp*sizeof(u64));
|
||||
#endif
|
||||
if( x.nNeeded ){
|
||||
x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);
|
||||
@@ -2574,8 +2629,9 @@ void sqlite3VdbeMakeReady(
|
||||
p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
|
||||
p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
|
||||
p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));
|
||||
p->anCycle = allocSpace(&x, p->anCycle, p->nOp*sizeof(u64));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -2591,8 +2647,9 @@ void sqlite3VdbeMakeReady(
|
||||
p->nMem = nMem;
|
||||
initMemArray(p->aMem, nMem, db, MEM_Undefined);
|
||||
memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*));
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
memset(p->anExec, 0, p->nOp*sizeof(i64));
|
||||
memset(p->anCycle, 0, p->nOp*sizeof(u64));
|
||||
#endif
|
||||
}
|
||||
sqlite3VdbeRewind(p);
|
||||
@@ -2651,8 +2708,9 @@ static void closeCursorsInFrame(Vdbe *p){
|
||||
int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){
|
||||
Vdbe *v = pFrame->v;
|
||||
closeCursorsInFrame(v);
|
||||
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
|
||||
#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)
|
||||
v->anExec = pFrame->anExec;
|
||||
v->anCycle = pFrame->anCycle;
|
||||
#endif
|
||||
v->aOp = pFrame->aOp;
|
||||
v->nOp = pFrame->nOp;
|
||||
@@ -3485,10 +3543,12 @@ int sqlite3VdbeReset(Vdbe *p){
|
||||
}
|
||||
for(i=0; i<p->nOp; i++){
|
||||
char zHdr[100];
|
||||
i64 cnt = p->anExec[i];
|
||||
i64 cycles = p->anCycle[i];
|
||||
sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ",
|
||||
p->aOp[i].cnt,
|
||||
p->aOp[i].cycles,
|
||||
p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
|
||||
cnt,
|
||||
cycles,
|
||||
cnt>0 ? cycles/cnt : 0
|
||||
);
|
||||
fprintf(out, "%s", zHdr);
|
||||
sqlite3VdbePrintOp(out, i, &p->aOp[i]);
|
||||
|
||||
+46
-19
@@ -3092,7 +3092,15 @@ static int whereLoopAddBtreeIndex(
|
||||
** seek only. Then, if this is a non-covering index, add the cost of
|
||||
** visiting the rows in the main table. */
|
||||
assert( pSrc->pTab->szTabRow>0 );
|
||||
rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
|
||||
if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
|
||||
/* The pProbe->szIdxRow is low for an IPK table since the interior
|
||||
** pages are small. Thuse szIdxRow gives a good estimate of seek cost.
|
||||
** But the leaf pages are full-size, so pProbe->szIdxRow would badly
|
||||
** under-estimate the scanning cost. */
|
||||
rCostIdx = pNew->nOut + 16;
|
||||
}else{
|
||||
rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;
|
||||
}
|
||||
pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx);
|
||||
if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK|WHERE_EXPRIDX))==0 ){
|
||||
pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);
|
||||
@@ -3472,7 +3480,7 @@ static int whereLoopAddBtree(
|
||||
sPk.aiRowLogEst = aiRowEstPk;
|
||||
sPk.onError = OE_Replace;
|
||||
sPk.pTable = pTab;
|
||||
sPk.szIdxRow = pTab->szTabRow;
|
||||
sPk.szIdxRow = 3; /* TUNING: Interior rows of IPK table are very small */
|
||||
sPk.idxType = SQLITE_IDXTYPE_IPK;
|
||||
aiRowEstPk[0] = pTab->nRowLogEst;
|
||||
aiRowEstPk[1] = 0;
|
||||
@@ -4803,37 +4811,56 @@ static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){
|
||||
** order.
|
||||
*/
|
||||
static LogEst whereSortingCost(
|
||||
WhereInfo *pWInfo,
|
||||
LogEst nRow,
|
||||
int nOrderBy,
|
||||
int nSorted
|
||||
WhereInfo *pWInfo, /* Query planning context */
|
||||
LogEst nRow, /* Estimated number of rows to sort */
|
||||
int nOrderBy, /* Number of ORDER BY clause terms */
|
||||
int nSorted /* Number of initial ORDER BY terms naturally in order */
|
||||
){
|
||||
/* TUNING: Estimated cost of a full external sort, where N is
|
||||
/* Estimated cost of a full external sort, where N is
|
||||
** the number of rows to sort is:
|
||||
**
|
||||
** cost = (3.0 * N * log(N)).
|
||||
** cost = (K * N * log(N)).
|
||||
**
|
||||
** Or, if the order-by clause has X terms but only the last Y
|
||||
** terms are out of order, then block-sorting will reduce the
|
||||
** sorting cost to:
|
||||
**
|
||||
** cost = (3.0 * N * log(N)) * (Y/X)
|
||||
** cost = (K * N * log(N)) * (Y/X)
|
||||
**
|
||||
** The (Y/X) term is implemented using stack variable rScale
|
||||
** below.
|
||||
** The constant K is at least 2.0 but will be larger if there are a
|
||||
** large number of columns to be sorted, as the sorting time is
|
||||
** proportional to the amount of content to be sorted. The algorithm
|
||||
** does not currently distinguish between fat columns (BLOBs and TEXTs)
|
||||
** and skinny columns (INTs). It just uses the number of columns as
|
||||
** an approximation for the row width.
|
||||
**
|
||||
** And extra factor of 2.0 or 3.0 is added to the sorting cost if the sort
|
||||
** is built using OP_IdxInsert and OP_Sort rather than with OP_SorterInsert.
|
||||
*/
|
||||
LogEst rScale, rSortCost;
|
||||
assert( nOrderBy>0 && 66==sqlite3LogEst(100) );
|
||||
rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;
|
||||
rSortCost = nRow + rScale + 16;
|
||||
LogEst rSortCost, nCol;
|
||||
assert( pWInfo->pSelect!=0 );
|
||||
assert( pWInfo->pSelect->pEList!=0 );
|
||||
/* TUNING: sorting cost proportional to the number of output columns: */
|
||||
nCol = sqlite3LogEst((pWInfo->pSelect->pEList->nExpr+59)/30);
|
||||
rSortCost = nRow + nCol;
|
||||
if( nSorted>0 ){
|
||||
/* Scale the result by (Y/X) */
|
||||
rSortCost += sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;
|
||||
}
|
||||
|
||||
/* Multiple by log(M) where M is the number of output rows.
|
||||
** Use the LIMIT for M if it is smaller. Or if this sort is for
|
||||
** a DISTINCT operator, M will be the number of distinct output
|
||||
** rows, so fudge it downwards a bit.
|
||||
*/
|
||||
if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 && pWInfo->iLimit<nRow ){
|
||||
nRow = pWInfo->iLimit;
|
||||
if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 ){
|
||||
rSortCost += 10; /* TUNING: Extra 2.0x if using LIMIT */
|
||||
if( nSorted!=0 ){
|
||||
rSortCost += 6; /* TUNING: Extra 1.5x if also using partial sort */
|
||||
}
|
||||
if( pWInfo->iLimit<nRow ){
|
||||
nRow = pWInfo->iLimit;
|
||||
}
|
||||
}else if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT) ){
|
||||
/* TUNING: In the sort for a DISTINCT operator, assume that the DISTINCT
|
||||
** reduces the number of output rows by a factor of 2 */
|
||||
@@ -4985,11 +5012,11 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
|
||||
pWInfo, nRowEst, nOrderBy, isOrdered
|
||||
);
|
||||
}
|
||||
/* TUNING: Add a small extra penalty (5) to sorting as an
|
||||
/* TUNING: Add a small extra penalty (3) to sorting as an
|
||||
** extra encouragment to the query planner to select a plan
|
||||
** where the rows emerge in the correct order without any sorting
|
||||
** required. */
|
||||
rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 5;
|
||||
rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 3;
|
||||
|
||||
WHERETRACE(0x002,
|
||||
("---- sort cost=%-3d (%d/%d) increases cost %3d to %-3d\n",
|
||||
|
||||
+16
-1
@@ -270,6 +270,8 @@ int sqlite3WhereExplainBloomFilter(
|
||||
zMsg = sqlite3StrAccumFinish(&str);
|
||||
ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),
|
||||
pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
|
||||
|
||||
sqlite3VdbeScanStatus(v, sqlite3VdbeCurrentAddr(v)-1, 0, 0, 0, 0);
|
||||
return ret;
|
||||
}
|
||||
#endif /* SQLITE_OMIT_EXPLAIN */
|
||||
@@ -292,14 +294,27 @@ void sqlite3WhereAddScanStatus(
|
||||
){
|
||||
const char *zObj = 0;
|
||||
WhereLoop *pLoop = pLvl->pWLoop;
|
||||
if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){
|
||||
int wsFlags = pLoop->wsFlags;
|
||||
int viaCoroutine = 0;
|
||||
|
||||
if( (wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){
|
||||
zObj = pLoop->u.btree.pIndex->zName;
|
||||
}else{
|
||||
zObj = pSrclist->a[pLvl->iFrom].zName;
|
||||
viaCoroutine = pSrclist->a[pLvl->iFrom].fg.viaCoroutine;
|
||||
}
|
||||
sqlite3VdbeScanStatus(
|
||||
v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj
|
||||
);
|
||||
|
||||
if( viaCoroutine==0 ){
|
||||
if( (wsFlags & (WHERE_MULTI_OR|WHERE_AUTO_INDEX))==0 ){
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iTabCur);
|
||||
}
|
||||
if( wsFlags & WHERE_INDEXED ){
|
||||
sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
# 2022-12-05
|
||||
#
|
||||
# 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 implements regression tests for SQLite library. The
|
||||
# focus of this file is the "memdb" VFS
|
||||
#
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
set testprefix memdb1
|
||||
do_not_use_codec
|
||||
|
||||
ifcapable !deserialize {
|
||||
finish_test
|
||||
return
|
||||
}
|
||||
|
||||
db close
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
# Test that when using a memdb database, it is not possible to upgrade
|
||||
# to an EXCLUSIVE lock if some other client is holding SHARED.
|
||||
#
|
||||
sqlite3 db file:/test.db?vfs=memdb -uri 1
|
||||
sqlite3 db2 file:/test.db?vfs=memdb -uri 1
|
||||
|
||||
do_execsql_test 1.1 {
|
||||
CREATE TABLE t1(x, y);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
}
|
||||
|
||||
do_execsql_test -db db2 1.2 {
|
||||
BEGIN;
|
||||
SELECT * FROM t1;
|
||||
} {1 2}
|
||||
|
||||
do_execsql_test 1.3 {
|
||||
BEGIN;
|
||||
INSERT INTO t1 VALUES(3, 4);
|
||||
}
|
||||
|
||||
do_catchsql_test 1.4 {
|
||||
COMMIT
|
||||
} {1 {database is locked}}
|
||||
|
||||
do_execsql_test -db db2 1.5 {
|
||||
SELECT * FROM t1;
|
||||
END;
|
||||
} {1 2}
|
||||
|
||||
do_execsql_test 1.6 {
|
||||
COMMIT
|
||||
} {}
|
||||
|
||||
do_execsql_test -db db2 1.7 {
|
||||
SELECT * FROM t1
|
||||
} {1 2 3 4}
|
||||
|
||||
finish_test
|
||||
@@ -43,6 +43,7 @@ do_test 1.0 {
|
||||
(NULL, 1, 3, 'one-c'),
|
||||
(NULL, 2, 1, 'two-a'),
|
||||
(NULL, 3, 1, 'three-a');
|
||||
ANALYZE;
|
||||
COMMIT;
|
||||
}
|
||||
} {}
|
||||
@@ -180,6 +181,7 @@ do_test 2.0 {
|
||||
(1, 3, 'one-c'),
|
||||
(20, 1, 'two-a'),
|
||||
(3, 1, 'three-a');
|
||||
ANALYZE;
|
||||
COMMIT;
|
||||
}
|
||||
} {}
|
||||
@@ -327,6 +329,7 @@ do_test 3.0 {
|
||||
(NULL, 1, 3, 'one-c'),
|
||||
(NULL, 2, 1, 'two-a'),
|
||||
(NULL, 3, 1, 'three-a');
|
||||
ANALYZE;
|
||||
COMMIT;
|
||||
}
|
||||
} {}
|
||||
|
||||
@@ -36,7 +36,9 @@ proc do_scanstatus_test {tn res} {
|
||||
while {1} {
|
||||
set r [sqlite3_stmt_scanstatus $stmt $idx]
|
||||
if {[llength $r]==0} break
|
||||
lappend ret {*}$r
|
||||
foreach v {nLoop nVisit nEst zName zExplain} {
|
||||
lappend ret $v [dict get $r $v]
|
||||
}
|
||||
incr idx
|
||||
}
|
||||
|
||||
@@ -312,8 +314,8 @@ do_execsql_test 5.1.1 {
|
||||
SELECT count(*) FROM t1 WHERE a IN (SELECT b FROM t1 AS ii)
|
||||
} {2}
|
||||
do_scanstatus_test 5.1.2 {
|
||||
nLoop 1 nVisit 10 nEst 10.0 zName t1bc
|
||||
zExplain {SCAN ii USING COVERING INDEX t1bc}
|
||||
nLoop 1 nVisit 10 nEst 10.0 zName t1
|
||||
zExplain {SCAN ii}
|
||||
nLoop 1 nVisit 2 nEst 8.0 zName sqlite_autoindex_t1_1
|
||||
zExplain {SEARCH t1 USING COVERING INDEX sqlite_autoindex_t1_1 (a=?)}
|
||||
}
|
||||
@@ -341,15 +343,15 @@ do_eqp_test 5.4.1 {
|
||||
SELECT count(*) FROM t1, t2 WHERE y = c;
|
||||
} {
|
||||
QUERY PLAN
|
||||
|--SCAN t1 USING COVERING INDEX t1bc
|
||||
|--SCAN t1
|
||||
`--SEARCH t2 USING COVERING INDEX t2xy (ANY(x) AND y=?)
|
||||
}
|
||||
do_execsql_test 5.4.2 {
|
||||
SELECT count(*) FROM t1, t2 WHERE y = c;
|
||||
} {200}
|
||||
do_scanstatus_test 5.4.3 {
|
||||
nLoop 1 nVisit 10 nEst 10.0 zName t1bc
|
||||
zExplain {SCAN t1 USING COVERING INDEX t1bc}
|
||||
nLoop 1 nVisit 10 nEst 10.0 zName t1
|
||||
zExplain {SCAN t1}
|
||||
nLoop 10 nVisit 200 nEst 56.0 zName t2xy
|
||||
zExplain {SEARCH t2 USING COVERING INDEX t2xy (ANY(x) AND y=?)}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
# 2022 December 5
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
#***********************************************************************
|
||||
#
|
||||
|
||||
set testdir [file dirname $argv0]
|
||||
source $testdir/tester.tcl
|
||||
set testprefix scanstatus2
|
||||
|
||||
ifcapable !scanstatus {
|
||||
finish_test
|
||||
return
|
||||
}
|
||||
|
||||
do_execsql_test 1.0 {
|
||||
CREATE TABLE t1(a, b);
|
||||
CREATE TABLE t2(x, y);
|
||||
INSERT INTO t1 VALUES(1, 2);
|
||||
INSERT INTO t1 VALUES(3, 4);
|
||||
INSERT INTO t2 VALUES('a', 'b');
|
||||
INSERT INTO t2 VALUES('c', 'd');
|
||||
INSERT INTO t2 VALUES('e', 'f');
|
||||
}
|
||||
|
||||
proc do_zexplain_test {v2 tn sql res} {
|
||||
db eval $sql
|
||||
set stmt [db version -last-stmt-ptr]
|
||||
set idx 0
|
||||
set ret [list]
|
||||
|
||||
set cmd sqlite3_stmt_scanstatus
|
||||
set f [list]
|
||||
if {$v2} { lappend f complex }
|
||||
|
||||
while {1} {
|
||||
set r [sqlite3_stmt_scanstatus -flags $f $stmt $idx]
|
||||
if {[llength $r]==0} break
|
||||
lappend ret [dict get $r zExplain]
|
||||
incr idx
|
||||
}
|
||||
uplevel [list do_test $tn [list set {} $ret] [list {*}$res]]
|
||||
}
|
||||
|
||||
proc get_cycles {stmt} {
|
||||
set r [sqlite3_stmt_scanstatus $stmt -1]
|
||||
dict get $r nCycle
|
||||
}
|
||||
|
||||
proc foreach_scan {varname stmt body} {
|
||||
upvar $varname var
|
||||
|
||||
for {set ii 0} {1} {incr ii} {
|
||||
set r [sqlite3_stmt_scanstatus -flags complex $stmt $ii]
|
||||
if {[llength $r]==0} break
|
||||
array set var $r
|
||||
uplevel $body
|
||||
}
|
||||
}
|
||||
|
||||
proc get_eqp_graph {stmt iPar nIndent} {
|
||||
set res ""
|
||||
foreach_scan A $stmt {
|
||||
if {$A(iParentId)==$iPar} {
|
||||
set txt $A(zExplain)
|
||||
if {$A(nCycle)>=0} {
|
||||
append txt " (nCycle=$A(nCycle))"
|
||||
}
|
||||
append res "[string repeat - $nIndent]$txt\n"
|
||||
append res [get_eqp_graph $stmt $A(iSelectId) [expr $nIndent+2]]
|
||||
}
|
||||
}
|
||||
set res
|
||||
}
|
||||
|
||||
proc get_graph {stmt} {
|
||||
set nCycle [get_cycles $stmt]
|
||||
set res "QUERY (nCycle=$nCycle)\n"
|
||||
append res [get_eqp_graph $stmt 0 2]
|
||||
}
|
||||
|
||||
proc do_graph_test {tn sql res} {
|
||||
db eval $sql
|
||||
set stmt [db version -last-stmt-ptr]
|
||||
set graph [string trim [get_graph $stmt]]
|
||||
|
||||
set graph [regsub -all {nCycle=[0-9]+} $graph nCycle=nnn]
|
||||
uplevel [list do_test $tn [list set {} $graph] [string trim $res]]
|
||||
}
|
||||
|
||||
proc puts_graph {sql} {
|
||||
db eval $sql
|
||||
set stmt [db version -last-stmt-ptr]
|
||||
puts [string trim [get_graph $stmt]]
|
||||
}
|
||||
|
||||
|
||||
do_zexplain_test 0 1.1 {
|
||||
SELECT (SELECT a FROM t1 WHERE b=x) FROM t2 WHERE y=2
|
||||
} {
|
||||
{SCAN t2}
|
||||
{SCAN t1}
|
||||
}
|
||||
do_zexplain_test 1 1.2 {
|
||||
SELECT (SELECT a FROM t1 WHERE b=x) FROM t2 WHERE y=2
|
||||
} {
|
||||
{SCAN t2}
|
||||
{CORRELATED SCALAR SUBQUERY 1}
|
||||
{SCAN t1}
|
||||
}
|
||||
|
||||
do_graph_test 1.3 {
|
||||
SELECT (SELECT a FROM t1 WHERE b=x) FROM t2 WHERE y=2
|
||||
} {
|
||||
QUERY (nCycle=nnn)
|
||||
--SCAN t2 (nCycle=nnn)
|
||||
--CORRELATED SCALAR SUBQUERY 1 (nCycle=nnn)
|
||||
----SCAN t1 (nCycle=nnn)
|
||||
}
|
||||
|
||||
do_graph_test 1.4 {
|
||||
WITH v2(x,y) AS MATERIALIZED (
|
||||
SELECT x,y FROM t2
|
||||
)
|
||||
SELECT * FROM t1, v2 ORDER BY y;
|
||||
} {
|
||||
QUERY (nCycle=nnn)
|
||||
--MATERIALIZE v2 (nCycle=nnn)
|
||||
----SCAN t2 (nCycle=nnn)
|
||||
--SCAN v2 (nCycle=nnn)
|
||||
--SCAN t1 (nCycle=nnn)
|
||||
--USE TEMP B-TREE FOR ORDER BY (nCycle=nnn)
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
do_execsql_test 2.0 {
|
||||
CREATE VIRTUAL TABLE ft USING fts5(a);
|
||||
INSERT INTO ft VALUES('abc');
|
||||
INSERT INTO ft VALUES('def');
|
||||
INSERT INTO ft VALUES('ghi');
|
||||
}
|
||||
|
||||
do_graph_test 2.1 {
|
||||
SELECT * FROM ft('def')
|
||||
} {
|
||||
QUERY (nCycle=nnn)
|
||||
--SCAN ft VIRTUAL TABLE INDEX 0:M1 (nCycle=nnn)
|
||||
}
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
reset_db
|
||||
do_execsql_test 3.0 {
|
||||
CREATE TABLE x1(a, b);
|
||||
CREATE TABLE x2(c, d);
|
||||
|
||||
WITH s(i) AS (SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<1000)
|
||||
INSERT INTO x1 SELECT i, i FROM s;
|
||||
INSERT INTO x2 SELECT a, b FROM x1;
|
||||
}
|
||||
|
||||
do_graph_test 2.1 {
|
||||
SELECT * FROM x1, x2 WHERE c=+a;
|
||||
} {
|
||||
QUERY (nCycle=nnn)
|
||||
--SCAN x1 (nCycle=nnn)
|
||||
--SEARCH x2 USING AUTOMATIC COVERING INDEX (c=?) (nCycle=nnn)
|
||||
}
|
||||
|
||||
finish_test
|
||||
|
||||
|
||||
@@ -191,4 +191,16 @@ do_test shell2-1.4.7 {
|
||||
SELECT 'unclosed;
|
||||
^--- error here}}
|
||||
|
||||
# Verify that safe mode rejects certain UDFs
|
||||
# Reported at https://sqlite.org/forum/forumpost/07beac8056151b2f
|
||||
do_test shell2-1.4.8 {
|
||||
catchcmd "-safe :memory:" {
|
||||
SELECT edit('DoNotCare');}
|
||||
} {1 {line 2: cannot use the edit() function in safe mode}}
|
||||
do_test shell2-1.4.9 {
|
||||
catchcmd "-safe :memory:" {
|
||||
SELECT writefile('DoNotCare', x'');}
|
||||
} {1 {line 2: cannot use the writefile() function in safe mode}}
|
||||
|
||||
|
||||
finish_test
|
||||
|
||||
@@ -595,4 +595,36 @@ do_execsql_test 17.1 {
|
||||
SELECT * FROM sqlite_master ORDER BY sql;
|
||||
} {}
|
||||
|
||||
# 2022-12-03 Ticket e8b674241947eb3b
|
||||
# Improve estimates for the cost of sorting relative
|
||||
# to the cost of doing an index lookup, so as to get
|
||||
# a better query plan. See the ticket for a deetailed
|
||||
# example.
|
||||
#
|
||||
reset_db
|
||||
do_execsql_test 18.1 {
|
||||
CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
|
||||
WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<50)
|
||||
-- increase to 5000 for actual test data ----^^
|
||||
INSERT INTO t1(a,b,c) SELECT x, random()%5000, random()%5000 FROM c;
|
||||
CREATE TABLE t2(d,e,f);
|
||||
WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<500)
|
||||
-- increase to 50000 for actual test data -----^^^
|
||||
INSERT INTO t2(d,e,f) SELECT
|
||||
NULLIF(0, random()%2), random()%5000, random()%5000
|
||||
FROM c;
|
||||
ANALYZE;
|
||||
UPDATE sqlite_stat1 SET stat='50000' WHERE tbl='t2';
|
||||
UPDATE sqlite_stat1 SET stat='5000' WHERE tbl='t1';
|
||||
ANALYZE sqlite_schema;
|
||||
} {}
|
||||
do_execsql_test 18.2 {
|
||||
EXPLAIN QUERY PLAN
|
||||
SELECT a FROM t1 JOIN t2
|
||||
WHERE a IN (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
|
||||
AND a=CASE WHEN d IS NOT NULL THEN e ELSE f END
|
||||
ORDER BY a;
|
||||
} {/.*SCAN t2.*SEARCH t1.*/}
|
||||
# ^^^^^^^--^^^^^^^^^--- t2 should be the outer loop.
|
||||
|
||||
finish_test
|
||||
|
||||
@@ -545,6 +545,7 @@ do_test where-6.1 {
|
||||
CREATE INDEX t3acb ON t3(a,c,b);
|
||||
INSERT INTO t3 SELECT w, 101-w, y FROM t1;
|
||||
SELECT count(*), sum(a), sum(b), sum(c) FROM t3;
|
||||
ANALYZE;
|
||||
}
|
||||
} {100 5050 5050 348550}
|
||||
do_test where-6.2 {
|
||||
|
||||
@@ -86,6 +86,7 @@ while {![eof $in]} {
|
||||
set in3($name) 0
|
||||
set out2($name) 0
|
||||
set out3($name) 0
|
||||
set ncycle($name) 0
|
||||
for {set i 3} {$i<[llength $line]-1} {incr i} {
|
||||
switch [string trim [lindex $line $i] ,] {
|
||||
same {
|
||||
@@ -107,6 +108,7 @@ while {![eof $in]} {
|
||||
in3 {set in3($name) 1}
|
||||
out2 {set out2($name) 1}
|
||||
out3 {set out3($name) 1}
|
||||
ncycle {set ncycle($name) 1}
|
||||
}
|
||||
}
|
||||
if {$group($name)} {
|
||||
@@ -140,6 +142,7 @@ foreach name {OP_Noop OP_Explain OP_Abortable} {
|
||||
set in3($name) 0
|
||||
set out2($name) 0
|
||||
set out3($name) 0
|
||||
set ncycle($name) 0
|
||||
set op($name) -1
|
||||
set order($nOp) $name
|
||||
incr nOp
|
||||
@@ -285,6 +288,7 @@ for {set i 0} {$i<=$max} {incr i} {
|
||||
if {$in3($name)} {incr x 8}
|
||||
if {$out2($name)} {incr x 16}
|
||||
if {$out3($name)} {incr x 32}
|
||||
if {$ncycle($name)} {incr x 64}
|
||||
}
|
||||
set bv($i) $x
|
||||
}
|
||||
@@ -299,6 +303,7 @@ puts "#define OPFLG_IN2 0x04 /* in2: P2 is an input */"
|
||||
puts "#define OPFLG_IN3 0x08 /* in3: P3 is an input */"
|
||||
puts "#define OPFLG_OUT2 0x10 /* out2: P2 is an output */"
|
||||
puts "#define OPFLG_OUT3 0x20 /* out3: P3 is an output */"
|
||||
puts "#define OPFLG_NCYCLE 0x40 /* ncycle:Cycles count against P1 */"
|
||||
puts "#define OPFLG_INITIALIZER \173\\"
|
||||
for {set i 0} {$i<=$max} {incr i} {
|
||||
if {$i%8==0} {
|
||||
|
||||
@@ -66,6 +66,8 @@ foreach stmt $allstmt {
|
||||
puts "********************************************************************"
|
||||
puts [string trim $sql($stmt)]
|
||||
puts "Execution count: $cnt($stmt)"
|
||||
set tcx 0
|
||||
set ttx 0
|
||||
for {set i 0} {[info exists stat($stmt,$i)]} {incr i} {
|
||||
foreach {cx tx detail} $stat($stmt,$i) break
|
||||
if {$cx==0} {
|
||||
@@ -74,7 +76,11 @@ foreach stmt $allstmt {
|
||||
set ax [expr {$tx/$cx}]
|
||||
}
|
||||
puts [format {%8d %12d %12d %4d %s} $cx $tx $ax $i $detail]
|
||||
incr tcx $cx
|
||||
incr ttx $tx
|
||||
}
|
||||
set tax [expr {$tcx>0?$ttx/$tcx:0}]
|
||||
puts [format {%8d %12d %12d TOTAL} $tcx $ttx $tax]
|
||||
}
|
||||
puts "********************************************************************"
|
||||
puts "OPCODES:"
|
||||
|
||||
Reference in New Issue
Block a user